背包九讲系列1——01背包、完全背包、多重背包

我在进行一些互联网公司的技术笔试的时候,对于我来说最大的难题莫过于最后的那几道编程题了,这对算法和数据结构有一定程度上的要求,而“动态规划”又是编程题中经常出现的算法类型,并且对于我这种没有搞过ACM竞赛的菜鸟来说,那更是非常难受。以至于很难通过笔试,所以打算好好的学习一下“动态规划”这个部分,就找到了动态规划的经典入门,背包9讲来学习和参考。背包9讲在网上也是有一定影响力的文章,是崔添翼大神的作品。我将分3 次,一次三讲,对文章中我认为可能不好理解的部分,再具体化一些并把实现代码发布上来。

进入主题吧

1 01背包问题

1.1 题目

有N 件物品和一个容量为V 的背包。放入第i 件物品耗费的费用是Ci,得到的价值是Wi。求解将哪些物品装入背包可使价值总和最大。

1.2 基本思路

这是最基础的背包问题,特点是:每种物品仅有一件,可以选择放或不放。用子问题定义状态:即F[i; v] 表示前i 件物品恰放入一个容量为v 的背包可以获得的最大价值。则其状态转移方程便是:

01背包最好理解的方程

这个方程非常重要,基本上所有跟背包相关的问题的方程都是由它衍生出来的。所以有必要将它详细解释一下:“将前i 件物品放入容量为v 的背包中”这个子问题,若只考虑第i 件物品的策略(放或不放),那么就可以转化为一个只和前i - 1 件物品相关的问题。如果不放第i 件物品,那么问题就转化为“前i -1 件物品放入容量为v 的背包中”,价值为F[i - 1; v];如果放第i 件物品,那么问题就转化为“前i - 1 件物品放入剩下的容量为v - Ci 的背包中”,此时能获得的最大价值就是F[i - 1; v - Ci] 再加上通过放入第i 件物品获得的价值Wi。

伪代码如下:

状态转移方程的伪代码

C++代码实现:

#include <iostream>
using namespace std;

const int W=10000;
const int N=100;

int dp_1[N+1][W+1];

int max(int a,int b)
{
    return a>b?a:b;
}

int main()
{
    int n,w;
    cin>>n>>w;

    int *w1=new int [n];
    int *v=new int [n];

    int i;
    
    for(i=0;i<n;i++)
    {
        cin>>w1[i]>>v[i];
    }

    for(i=0;i<w;i++)
    {
        if(i>=w1[0])
        {
            dp_1[0][i]=v[0];
        }
        else
        {
            dp_1[0][i]=0;
        }
    }

    for(i=1;i<n;i++)
    {
        for(int j=0;j<=w;j++)
        {
            if(j>=w1[i])
            {
                dp_1[i][j]=max(dp_1[i-1][j],dp_1[i-1][j-w1[i]]+v[i]);
            }
            else
            {
                dp_1[i][j]=dp_1[i-1][j];
            }
        }
    }
    
    delete [] w1;
    delete [] v;
    cout<<dp_1[n-1][w]<<endl;
    return 0;
}

1.3 优化空间复杂度

以上方法的时间和空间复杂度均为O(V N),其中时间复杂度应该已经不能再优化了,但空间复杂度却可以优化到O(V )。先考虑上面讲的基本思路如何实现,肯定是有一个主循环i ←1 ...N,每次算出来二维数组F[i,0... V ] 的所有值。那么,如果只用一个数组F[0 ... V ],能不能保证第i次循环结束后F[v] 中表示的就是我们定义的状态F[i,v] 呢?F[i,v] 是由F[i - 1, v] 和F[i - 1, v - Ci] 两个子问题递推而来,能否保证在推F[i, v] 时(也即在第i 次主循环中推F[v] 时)能够取用F[i - 1, v] 和F[i - 1, v - Ci] 的值呢?事实上,这要求在每次主循环中我们以v ←V ... 0 的递减顺序计算F[v],这样才能保证计算F[v] 时F[v -Ci] 保存的是状态F[i - 1; v - Ci] 的值。伪代码如下:

优化后的伪代码

C++代码实现:

#include <iostream>
using namespace std;

const int W=10000;
int dp[W+1];

int max(int a,int b)
{
    return a>b?a:b;
}

int main()
{
    int n,w;
    cin>>n>>w;
    int i,j,wi,pi;
    for(i=0;i<n;i++)
    {
        cin>>wi>>pi;
        if(i==0)
        {
            for(j=0;j<=w;j++)
            {
                if(j>=wi)
                {
                    dp[j]=pi;
                }
                else
                {
                    dp[j]=0;
                }
            }
        }
        else
        {
            for(j=w;j>=wi;j--)
            {       
               dp[j]=max(dp[j],dp[j-wi]+pi);
            }
        }
    }

    cout<<dp[w]<<endl;
    return 0;
}

其中的F[v] =max{fF[v], F[v - Ci] +Wi} 一句,恰就对应于我们原来的转移方程,因为现在的F[v - Ci] 就相当于原来的F[i - 1, v - Ci]。如果将v 的循环顺序从上面的逆序改成顺序的话,那么则成了F[i, v] 由F[i, v - Ci] 推导得到,与本题意不符。

对于为什么需要逆序从v到0遍历而不是从0到v遍历,我们来举例子具体化的说明一下

举例子

而如果逆序的话,你会发现F数组当前索引的值的计算依赖于前面索引的值,不会使用到被更新过的值。这样F数组就能在i-1的情况下完成i趟遍历的更新。

------下面回归文章主线------

事实上,使用一维数组解01 背包的程序在后面会被多次用到,所以这里抽象出一个处理一件01 背包中的物品过程,以后的代码中直接调用不加说明。

抽象成方法的伪代码

有了这个过程以后,01 背包问题的伪代码就可以这样写:

1.4 初始化的细节问题

我们看到的求最优解的背包问题题目中,事实上有两种不太相同的问法。有的题目要求“恰好装满背包”时的最优解,有的题目则并没有要求必须把背包装满。一种区别这两种问法的实现方法是在初始化的时候有所不同。如果是第一种问法,要求恰好装满背包,那么在初始化时除了F[0] 为0,其它F[1...V ] 均设为-∞,这样就可以保证最终得到的F[V ] 是一种恰好装满背包的最优解。如果并没有要求必须把背包装满,而是只希望价格尽量大,初始化时应该将F[0...V ]全部设为0。
这是为什么呢?可以这样理解:初始化的F 数组事实上就是在没有任何物品可以放入背包时的合法状态。如果要求背包恰好装满,那么此时只有容量为0 的背包可以在什么也不装且价值为0 的情况下被“恰好装满”,其它容量的背包均没有合法的解,属于未定义的状态,应该被赋值为-∞ 了。如果背包并非必须被装满,那么任何容量的背包都有一个合法解“什么都不装”,这个解的价值为0,所以初始时状态的值也就全部为0了。这个小技巧完全可以推广到其它类型的背包问题,后面不再对进行状态转移之前的初始化进行讲解。

1.5 一个常数优化

上面伪代码中的
for i 1 to N
for v V to Ci
中第二重循环的下限可以改进。它可以被优化为

这个优化之所以成立的原因请读者自己思考。(提示:使用二维的转移方程思考较易。)

我表示还没想到,请各位大神看到这里帮忙解答一下。

1.6 小结

01 背包问题是最基本的背包问题,它包含了背包问题中设计状态、方程的最基本思想。另外,别的类型的背包问题往往也可以转换成01 背包问题求解。故一定要仔细体会上面基本思路的得出方法,状态转移方程的意义,以及空间复杂度怎样被优化。

2 完全背包问题

2.1 题目

有N 种物品和一个容量为V 的背包,每种物品都有无限件可用。放入第i 种物品的费用是Ci,价值是Wi。求解:将哪些物品装入背包,可使这些物品的耗费的费用总和不超过背包容量,且价值总和最大。

2.2 基本思路
这个问题非常类似于01 背包问题,所不同的是每种物品有无限件。也就是从每种物品的角度考虑,与它相关的策略已并非取或不取两种,而是有取0 件、取1 件、取2
件……直至取⌊V /Ci⌋ 件等许多种。如果仍然按照解01 背包时的思路,令F[i; v] 表示前i 种物品恰放入一个容量为v的背包的最大权值。仍然可以按照每种物品不同的策略写出状态转移方程,像这样:

状态转移方程

这跟01 背包问题一样有O(V N) 个状态需要求解,但求解每个状态的时间已经不是常数了,求解状态F[i,v] 的时间是O(v/Ci),总的复杂度可以认为是O(NV ∑ V/Ci),是比较大的。将01 背包问题的基本思路加以改进,得到了这样一个清晰的方法。这说明01 背包问题的方程的确是很重要,可以推及其它类型的背包问题。但我们还是要试图改进这个复杂度。

2.3 一个简单有效的优化

完全背包问题有一个很简单有效的优化,是这样的:若两件物品i、j 满足Ci ≤ Cj且Wi ≥ Wj,则将可以将物品j 直接去掉,不用考虑。这个优化的正确性是显然的:任何情况下都可将价值小费用高的j 换成物美价廉的i,得到的方案至少不会更差。对于随机生成的数据,这个方法往往会大大减少物品的件数,从而加快速度。然而这个并不能改善最坏情况的复杂度,因为有可能特别设计的数据可以一件物品也去不掉。

这个优化可以简单的O(N^2) 地实现,一般都可以承受。另外,针对背包问题而言,比较不错的一种方法是:首先将费用大于V 的物品去掉,然后使用类似计数排序的做法,计算出费用相同的物品中价值最高的是哪个,可以O(V + N) 地完成这个优化。这个不太重要的过程就不给出伪代码了,希望你能独立思考写出伪代码或程序。

O(N^2) 优化部分代码:

就是先将数值赋值到一个数组,然后进行比较处理掉不符合规则的数值,再重新赋值到另一个数组中去。

int main()
{
    int n,w;
    cin>>n>>w;

    int *w1=new int [n];
    int *v=new int [n];
    
    int i,wi,vi;
    
    for(i=0;i<n;i++)
    {
        cin>>wi>>vi;
        w1[i]=wi;
        v[i]=vi;
    }
    
    int j;
    int len=n;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n;j++)
        {
            if(w1[i]>w1[j]&&v[i]<=v[j]||w1[i]>w)
            {
                w1[i]=-1;
                v[i]=-1;
                len--;
            }
        }
    }
    
    cout<<"after delete"<<endl;
    
    int *w2=new int [len];
    int *v2=new int [len];
    
    for(i=0,j=0;i<n;i++)
    {
        if(w1[i]!=-1)
        {
            w2[j]=w1[i];
            v2[j]=v[i];
            j++;
        }

    }
    delete [] w1;
    delete [] v;
    
    for(i=0;i<len;i++)
    {
        cout<<w2[i]<<"   "<<v2[i]<<endl;
    }

    return 0;
}

O(V + N)优化部分代码:

就首先将读入的数值以key(体积) value(价值)的形式存入map中,然后不断更新map中相同体积的值,获取最大值。同时把体积大于w总容量的数据去掉。

int main()
{

    int n,w;
    cin>>n>>w;
    map<int,int > m;

    int i,wi,vi;

    for(i=0;i<n;i++)
    {
        cin>>wi>>vi;
        if(wi<=w)  // 费用大于w的去掉
        {
            if(m.find(wi)!=m.end())
            {
                if(m[wi]<vi)  //费用(体积)相同时 选择更大的价值
                {
                    m[wi]=vi;
                }
            }
            else
            {
                m[wi]=vi;
            }
        }
    }

    map<int,int>::iterator it;

    it=m.begin();

    while(it!=m.end())
    {
        cout<<it->first<<"    "<<it->second<<endl;
        it++;
    }

    return 0;
}

2.4 转化为01 背包问题求解

01 背包问题是最基本的背包问题,我们可以考虑把完全背包问题转化为01 背包问题来解。
最简单的想法是,考虑到第i 种物品最多选⌊V /Ci⌋ 件,于是可以把第i 种物品转化为⌊V /Ci⌋ 件费用及价值均不变的物品,然后求解这个01 背包问题。这样的做法完全没有改进时间复杂度,但这种方法也指明了将完全背包问题转化为01 背包问题的思路:将一种物品拆成多件只能选0 件或1 件的01 背包中的物品。更高效的转化方法是:把第i 种物品拆成费用Ci * 2^k、价值为Wi * 2^k 的若干件物品,其中k 取遍满足Ci*2^k ≤ V 的非负整数。这是二进制的思想。因为,不管最优策略选几件第i 种物品,其件数写成二进制后,总可以表示成若干个2^k 件物品的和。这样一来就把每种物品拆成O(log ⌊V /Ci⌋) 件物品,是一个很大的改进。

2.5 O(V N) 的算法

这个算法使用一维数组,先看伪代码:

一维数组伪代码

你会发现,这个伪代码与01 背包问题的伪代码只有v 的循环次序不同而已。
为什么这个算法就可行呢?首先想想为什么01 背包中要按照v 递减的次序来循环。让v 递减是为了保证第i 次循环中的状态F[i; v] 是由状态F[i - 1, v - Ci] 递推而来。换句话说,这正是为了保证每件物品只选一次,保证在考虑“选入第i 件物品”这件策略时,依据的是一个绝无已经选入第i 件物品的子结果F[i -1, v - Ci]。而现在完全背包的特点恰是每种物品可选无限件,所以在考虑“加选一件第i 种物品”这种策略时,却正需要一个可能已选入第i 种物品的子结果F[i, v-Ci],所以就可以并且必须采用v递增的顺序循环。这就是这个简单的程序为何成立的道理。
值得一提的是,上面的伪代码中两层for 循环的次序可以颠倒。这个结论有可能会带来算法时间常数上的优化。
这个算法也可以由另外的思路得出。例如,将基本思路中求解F[i,v -Ci] 的状态转移方程显式地写出来,代入原方程中,会发现该方程可以等价地变形成这种形式:

C++代码实现:

int main()
{
    int n;
    cin>>n;
    while(n--)
    {

        int money;
        cin>>money;

        int i;

        for(i=0;i<3;i++)
        {
            for(int j=0;j<=money;j++)
            {
                if(j>=v[i])
                {
                    dp_1[j]=max(dp_1[j],dp_1[j-v[i]]+v[i]);
                }
            }
        }

        cout<<money-dp_1[money]<<endl;
    }
    return 0;
}

将这个方程用一维数组实现,便得到了上面的伪代码。
最后抽象出处理一件完全背包类物品的过程伪代码:

抽象函数伪代码
2.6 小结

完全背包问题也是一个相当基础的背包问题,它有两个状态转移方程。希望读者能够对这两个状态转移方程都仔细地体会,不仅记住,也要弄明白它们是怎么得出来的,最好能够自己想一种得到这些方程的方法。
事实上,对每一道动态规划题目都思考其方程的意义以及如何得来,是加深对动态规划的理解、提高动态规划功力的好方法。

3 多重背包问题

3.1 题目

有N 种物品和一个容量为V 的背包。第i 种物品最多有Mi 件可用,每件耗费的空间是Ci,价值是Wi。求解将哪些物品装入背包可使这些物品的耗费的空间总和不超过背包容量,且价值总和最大。

3.2 基本算法
这题目和完全背包问题很类似。基本的方程只需将完全背包问题的方程略微一改即可。因为对于第i 种物品有Mi + 1 种策略:取0 件,取1 件……取Mi 件。令F[i, v]表示前i 种物品恰放入一个容量为v 的背包的最大价值,则有状态转移方程:

状态转移方程

3.3 转化为01 背包问题
另一种好想好写的基本方法是转化为01 背包求解:把第i 种物品换成Mi 件01背包中的物品,则得到了物品数为∑Mi 的01 背包问题。直接求解之,复杂度仍然是O(V ∑Mi)。
但是我们期望将它转化为01 背包问题之后,能够像完全背包一样降低复杂度。
仍然考虑二进制的思想,我们考虑把第i 种物品换成若干件物品,使得原问题中第i 种物品可取的每种策略——取0...Mi 件——均能等价于取若干件代换以后的物品。另外,取超过Mi 件的策略必不能出现。方法是:将第i 种物品分成若干件01 背包中的物品,其中每件物品有一个系数。这件物品的费用和价值均是原来的费用和价值乘以这个系数。令这些系数分别为1、 2、2^2 ... 2^k-1,Mi - 2^k + 1,且k 是满足Mi - 2^k + 1 > 0 的最大整数。例如,如果Mi为13,则相应的k = 3,这种最多取13 件的物品应被分成系数分别为1、2、4、6 的四件
物品。

分成的这几件物品的系数和为Mi,表明不可能取多于Mi 件的第i 种物品。另外这种方法也能保证对于0 ...Mi 间的每一个整数,均可以用若干个系数的和表示。这里算法正确性的证明可以分0... 2^(k-1) 和2k...Mi 两段来分别讨论得出,希望读者自己思考尝试一下。

这样就将第i 种物品分成了O(logMi) 种物品, 将原问题转化为了复杂度为O(V ∑logMi) 的01 背包问题,是很大的改进。

下面给出O(logM) 时间处理一件多重背包中物品的过程:

处理一件多重背包的伪代码

希望你仔细体会这个伪代码,如果不太理解的话,不妨翻译成程序代码以后,单步执行几次,或者头脑加纸笔模拟一下,以加深理解。

c++代码实现:


void completePack(int dp[],int value,int weight,int total)
{
    int i;
    for(i=weight;i<=total;i++)
    {
        dp[i]=max(dp[i],dp[i-weight]+value);
    }
}

void ZeroOnePack(int dp[],int value,int weight,int total)
{
    int i;
    for(i=total;i>=weight;i--)
    {
        dp[i]=max(dp[i],dp[i-weight]+value);
    }
}


//多重背包问题 优化 一维数组 二进制的思想  时间复杂度为O(V*Σlog n[i])
void mutiPack(int dp[],int value,int weight,int amount,int total)
{
    if(weight*amount>total)
    {
        completePack(dp,value,weight,total);
    }
    else
    {
        int k=1;
        while(amount-k>=0)
        {
            ZeroOnePack(dp,k*value,k*weight,total);
            amount-=k;
            k*=2;
        }
        ZeroOnePack(dp,amount*value,amount*weight,total);
    }
}


int main()
{
    int n,w;
    cin>>n>>w;
    int i;
    int wi,vi,ci;
    for(i=0;i<n;i++)
    {
        cin>>wi>>vi>>ci;
        mutiPack(dp_1,vi,wi,ci,w);
    }

    cout<<dp_1[w]<<endl;
    return 0;
}

3.4 可行性问题O(V N) 的算法
当问题是“每种有若干件的物品能否填满给定容量的背包”,只须考虑填满背包的可行性,不需考虑每件物品的价值时,多重背包问题同样有O(V N) 复杂度的算法。
例如,可以使用单调队列的数据结构,优化基本算法的状态转移方程,使每个状态的值可以以均摊O(1) 的时间求解。
下面介绍一种实现较为简单的O(V N) 复杂度解多重背包问题的算法。它的基本思想是这样的:设F[i; j] 表示“用了前i 种物品填满容量为j 的背包后,最多还剩下几个第i 种物品可用”,如果F[i, j] = -1 则说明这种状态不可行,若可行应满足0 ≤ F[i,j] ≤ Mi。
递推求F[i,j] 的伪代码如下:

伪代码

最终F[N][0 ... V ] 便是多重背包可行性问题的答案。

3.5 小结
在这一讲中,我们看到了将一个算法的复杂度由O(V ∑Mi) 改进到O(V ∑ logMi) 的过程,还知道了存在复杂度为O(V N) 的算法。希望你特别注意“拆分物品”的思想和方法,自己证明一下它的正确性,并将完整的程序代码写出来。

推荐阅读更多精彩内容