01背包问题

题目

有N件物品和一个容量为V的背包。第i件物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使价值总和最大。

基本思路

这是最基础的背包问题，特点是：每种物品仅有一件，可以选择放或不放。

用子问题定义状态：即f[i][v]表示前i件物品恰放入一个容量为v的背包可以获得的最大价值。则其状态转移方程便是：
f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]+w[i]}

“将前i件物品放入容量为v的背包中”这个子问题，若只考虑第i件物品的策略（放或不放），那么就可以转化为一个只牵扯前i-1件物品的问题。
如果不放第i件物品，那么问题就转化为“前i-1件物品放入容量为v的背包中”，价值为f[i-1][v]；
如果放第i件物品，那么问题就转化为“前i-1件物品放入剩下的容量为v-c[i]的背包中”，此时能获得的最大价值就是f[i-1][v-c[i]]再加上通过放入第i件物品获得的价值w[i]。

1
2
3
4
5
6
//O(NV)
f[0][0 ~ V] = 0;
for(int i = 1; i <= n; ++i)
    for(int j = 0; j <= V; ++j)
        if(j < w[i]) f[i][j] = f[i - 1][j];
        else f[i][j] = max(f[i - 1][j], f[i - 1][j - w[i]] + v[i]);

优化空间复杂度

以上方法的时间和空间复杂度均为O(VN)，其中时间复杂度应该已经不能再优化了，但空间复杂度却可以优化到O。

先考虑上面讲的基本思路如何实现，肯定是有一个主循环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-c[i]]两个子问题递推而来，能否保证在推f[i][v]时（也即在第i次主循环中推f[v]时）能够得到f[i-1][v]和f[i-1][v-c[i]]的值呢？
事实上，这要求在每次主循环中我们以v=V..0的顺序推f[v]，这样才能保证推f[v]时f[v-c[i]]保存的是状态f[i-1][v-c[i]]的值。伪代码如下：

1
2
3
for i=1..N
    for v=V..0
        f[v]=max{f[v],f[v-c[i]]+w[i]};

其中的f[v]=max{f[v],f[v-c[i]]}一句恰就相当于我们的转移方程f[i][v]=max{f[i-1][v],f[i-1][v-c[i]]}，因为现在的f[v-c[i]]就相当于原来的f[i-1][v-c[i]]。如果将v的循环顺序从上面的逆序改成顺序的话，那么则成了f[i][v]由f[i][v-c[i]]推知，与本题意不符，但它却是另一个重要的背包问题P02最简捷的解决方案，故学习只用一维数组解01背包问题是十分必要的。

1
2
3
4
5
//O(NV) 滚动数组
f[0 ~ V] = 0;
for(int i = 1; i <= n; ++i)
    for(int j = V; j >= w[i]; --j)
        f[j] = max(f[j], f[j - w[i]] + v[i]);

一个常数优化

前面的伪代码中有 for v=V..1，可以将这个循环的下限进行改进。

由于只需要最后f[v]的值，倒推前一个物品，其实只要知道f[v-w[n]]即可。以此类推，对以第j个背包，其实只需要知道到f[v-sum{w[j..n]}]即可，即代码中的

1
2
for i=1..N
    for v=V..0

可以改成

1
2
3
for i=1..n
    bound=max{V-sum{w[i..n]},c[i]}
    for v=V..bound

这对于V比较大时是有用的。

例题及代码

http://www.lintcode.com/zh-cn/problem/backpack-ii/
二维数组法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public static int ZeroOnePack(int m, int[] A, int V[]) {
    //m背包体积,A体积，V价值
    // write your code here
    int[][] dp = new int[A.length + 1][m + 1];
    for (int i = 1; i <= A.length; i++) {
        for (int j = 1; j <= m; j++) {
            if (j >= A[i - 1]) {
                dp[i][j] = Math.max(V[i - 1] + dp[i - 1][j - A[i - 1]], dp[i - 1][j]);
            } else {
                dp[i][j] = dp[i - 1][j];
            }
        }
    }
    // System.out.println(Arrays.deepToString(dp));
    return dp[A.length][m];
}

一维数组法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public static int ZeroOnePack(int m, int[] A, int V[]) {
    //m背包体积,A体积，V价值
    // write your code here
    int[] dp = new int[m + 1];
    for (int i = 1; i <= A.length; i++) {
      //逆序
        for (int j = m; j >= 0; j--) {
            if (j >= A[i - 1]) {
                dp[j] = Math.max(V[i - 1] + dp[j - A[i - 1]], dp[j]);
            } else {
              //这里后面的dp[j]代表的是dp[i-1][j]，即没有上一行的数值
                dp[j] = dp[j];
            }
        }
    }
    // System.out.println(Arrays.deepToString(dp));
    return dp[m];
}

完全背包问题

题目

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

基本思路

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

f[i][v]=max{f[i-1][v-k*c[i]]+k*w[i]|0<=k*c[i]<=v}

这跟01背包问题一样有O(VN)个状态需要求解，但求解每个状态的时间已经不是常数了，求解状态f[i][v]的时间是O(v/c[i])，总的复杂度可以认为是O(V*Σ(V/c[i]))，是比较大的。

转化为01背包问题求解

既然01背包问题是最基本的背包问题，那么我们可以考虑把完全背包问题转化为01背包问题来解。最简单的想法是，考虑到第i种物品最多选V/c[i]件，于是可以把第i种物品转化为V/c[i]件费用及价值均不变的物品，然后求解这个01背包问题。这样完全没有改进基本思路的时间复杂度，但这毕竟给了我们将完全背包问题转化为01背包问题的思路：将一种物品拆成多件物品。

更高效的转化方法是：把第i种物品拆成费用为c[i]*2^k、价值为w[i]*2^k的若干件物品，其中k满足c[i]*2^k<=V。这是二进制的思想，因为不管最优策略选几件第i种物品，总可以表示成若干个2^k件物品的和。这样把每种物品拆成O(log V/c[i])件物品，是一个很大的改进。

1
2
3
4
5
6
//O(NVK)
f[0][0 ~ V] = 0;
for(int i = 1; i <= n; ++i)
    for(int j = 0; j <= V; ++j)
        for(int k = 0; k * w[i] <= j; ++k)
            f[i][j] = max(f[i][j], f[i - 1][j - k * w[i]] + k * v[i]);

O(VN)的算法

这个算法使用一维数组，先看伪代码：

1
2
3
for i=1..N
    for v=0..V
        f[v]=max{f[v],f[v-cost]+weight}

你会发现，这个伪代码与P01的伪代码只有v的循环次序不同而已。为什么这样一改就可行呢？首先想想为什么P01中要按照v=V..0的逆序来循环。这是因为要保证第i次循环中的状态f[i][v]是由状态f[i-1][v-c[i]]递推而来。换句话说，这正是为了保证每件物品只选一次，保证在考虑“选入第i件物品”这件策略时，依据的是一个绝无已经选入第i件物品的子结果f[i-1][v-c[i]]。而现在完全背包的特点恰是每种物品可选无限件，所以在考虑“加选一件第i种物品”这种策略时，却正需要一个可能已选入第i种物品的子结果f[i][v-c[i]]，所以就可以并且必须采用v=0..V的顺序循环。这就是这个简单的程序为何成立的道理。

值得一提的是，上面的伪代码中两层for循环的次序可以颠倒。这个结论有可能会带来算法时间常数上的优化。

这个算法也可以以另外的思路得出。例如，将基本思路中求解f[i][v-c[i]]的状态转移方程显式地写出来，代入原方程中，会发现该方程可以等价地变形成这种形式：
f[i][v]=max{f[i-1][v],f[i][v-c[i]]+w[i]}
将这个方程用一维数组实现，便得到了上面的伪代码。

最后抽象出处理一件完全背包类物品的过程伪代码：

1
2
3
4
5
6
7
8
9
10
11
12
//O(NV)
f[0][0 ~ V] = 0;
for(int i = 1; i <= n; ++i)
    for(int j = 0; j <= V; ++j)
        if(j < w[i]) f[i][j] = f[i - 1][j];
        else f[i][j] = max(f[i - 1][j], f[i][j - w[i]] + v[i]);
//O(NV) 滚动数组
f[0 ~ V] = 0;
for(int i = 1; i <= n; ++i)
    for(int j = w[i]; j <= V; ++j)
        f[j] = max(f[j], f[j - w[i]] + v[i]);

多重背包问题

题目

有N种物品和一个容量为V的背包。第i种物品最多有n[i]件可用，每件费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

基本算法

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

f[i][v]=max{f[i-1][v-k*c[i]]+k*w[i]|0<=k<=n[i]}

复杂度是O(V*Σn[i])。

转化为01背包问题

另一种好想好写的基本方法是转化为01背包求解：把第i种物品换成n[i]件01背包中的物品，则得到了物品数为Σn[i]的01背包问题，直接求解，复杂度仍然是O(V*Σn[i])。

但是我们期望将它转化为01背包问题之后能够像完全背包一样降低复杂度。仍然考虑二进制的思想，我们考虑把第i种物品换成若干件物品，使得原问题中第i种物品可取的每种策略——取0..n[i]件——均能等价于取若干件代换以后的物品。另外，取超过n[i]件的策略必不能出现。

1
2
3
4
5
6
7
8
9
10
11
12
13
//O(NVK)
f[0][0 ~ V] = 0;
for(int i = 1; i <= n; ++i)
    for(int j = 0; j <= V; ++j)
        for(int k = 0; k <= c[i] && k * w[i] <= j; ++k)
            f[i][j] = max(f[i][j], f[i - 1][j - k * w[i]] + k * v[i]);
//O(NVK)
f[0 ~ V] = 0;
for(int i = 1; i <= n; ++i)
    for(int j = V; j >= 0; --j)
        for(int k = 1; k <= c[i] && k * w[i] <= j; ++k)
            f[j] = max(f[j], f[j - k * w[i]] + k * v[i]);

多重背包的优化

二进制优化

ci=1+2+4+⋯+2^k+a, 0≤a<2^k+1 1,="" 2,="" 4,="" ⋯,="" 2k可以表示0∼2k+1−1的整数，基于二进制表示1,="" 2^k可以表示0∼2^(k+1)−1的整数，基于二进制表示="" 再由a即可得到0∼ci的所有整数了再由a即可得到0∼ci的所有整数了="" 这样物品个数由ci个变为logci个，时间复杂度即为o(nvlogk)="" 

1
2
3
4
5
6
7
8
9
10
11
12
//O(NVlogK)
f[0 ~ V] = 0;
for(int i = 1; i <= n; ++i){
    int num = c[i];
    for(int k = 1; num > 0; k <<= 1){
        int mul = min(k, num);
        for(int j = V; mul * w[i] <= j; --j){
            f[i] = max(f[j], f[j - mul * w[i]] + mul * v[i])
        }
        num -= mul;
    }
}

初始化的细节问题

我们看到的求最优解的背包问题题目中，事实上有两种不太相同的问法。
有的题目要求“恰好装满背包”时的最优解，有的题目则并没有要求必须把背包装满。
一种区别这两种问法的实现方法是在初始化的时候有所不同。

如果要求恰好装满背包，那么在初始化时除了f[0]为0其它f[1..V]均设为-∞，这样就可以保证最终得到的f[N]是一种恰好装满背包的最优解。

如果并没有要求必须把背包装满，而是只希望价格尽量大，初始化时应该将f[0..V]全部设为0。

为什么呢？可以这样理解：初始化的f数组事实上就是在没有任何物品可以放入背包时的合法状态。如果要求背包恰好装满，那么此时只有容量为0的背包可能被价值为0的nothing“恰好装满”，其它容量的背包均没有合法的解，属于未定义的状态，它们的值就都应该是-∞了。如果背包并非必须被装满，那么任何容量的背包都有一个合法解“什么都不装”，这个解的价值为0，所以初始时状态的值也就全部为0了。

http://love-oriented.com/pack/
http://taosama.com/2016/05/18/%E8%83%8C%E5%8C%85%E9%97%AE%E9%A2%98%EF%BC%8801%E8%83%8C%E5%8C%85%E3%80%81%E5%AE%8C%E5%85%A8%E8%83%8C%E5%8C%85%E3%80%81%E5%A4%9A%E9%87%8D%E8%83%8C%E5%8C%85%EF%BC%89/