背包问题总结分析
背包问题是个很经典的动态规划问题，本博客对背包问题及其常见变种的解法和思路进行总结分析
01背包
问题介绍
有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。
第 i 件物品的体积是 v[i]，价值是 w[i]。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
基本思路
定义int[][] dp，dp[i][j] 表示当容量为j时，对于前i个物品而言的最优放置策略（即最大价值）。对于物品 i 而言，只有放与不放，这两种选择。因此可以得到 状态转移方程：
-
放物品 i ：
dp[i][j] = dp[i - 1][j - v[i]] + w[i]； -
不放物品 i ：
dp[i][j] = dp[i - 1][j]。
直观方法：
// v和w数组长度都是 N + 1，v[0]和w[0]都是0
private static void backpack1(int N, int V, int[] v, int[] w) {
int[][] dp = new int[N + 1][V + 1];
for (int i = 1; i <= N; ++i) {
for (int j = 1; j <= V; ++j) {
dp[i][j] = dp[i - 1][j];
if (j >= v[i]) {
dp[i][j] = Math.max(dp[i][j], dp[i - 1][j - v[i]] + w[i]);
}
}
}
System.out.println(dp[N][V]);
}
这种方法空间不是最优的。观察代码发现，dp[i]只跟dp[i-1]有关，所以可以将二维降成一维。
优化方法：
private static void backpack2(int N, int V, int[] v, int[] w) {
int[] dp = new int[V + 1];
for (int i = 1; i <= N; ++i) {
for (int j = V; j >= v[i]; --j) {
dp[j] = Math.max(dp[j], dp[j - v[i]] + w[i]);
}
}
System.out.println(dp[V]);
}
注意：
内层循环不能顺序枚举。dp[j - v[i]] 实际上相当于 dp[i - 1][j - v[i]] ，而不是dp[i][j - v[i]] ，如果顺序枚举， dp[i] 的 j - v[i] 的位置已经被计算过，覆盖了。所以应该通过倒序枚举来规避这个问题。
两个要点：
-
若 dp[] 全部初始化为0，计算结果的 dp[V] 就是答案；
-
若 dp[0] 初始化为0，其它元素全部初始化为负无穷，则最后遍历dp[]得到最大值为答案。
解释如下：
dp[V] 一定是最大值。同样遍历了所有物品情况下，容量 V 大于 V - X ，最后得到的价值 dp[V] 必然大于 dp[V - X]。
dp数组初始化值全为 0 ，则允许dp[V]从任何一个初始项转化而来，并不一定是 dp[0]。最终结果如果从 dp[k] 转化而来，说明有 k 体积的空余。但是，如果我们更改一下dp数组初始化的情况：
将 dp[0][0] 取0 ，dp[0][1] ~ dp[0][V]全部取负无穷，同样计算，得到的结果 dp[N][1] ~ dp[N][V] 中最后一位数不一定是最大值。循环求MAX，可排除掉从“负无穷”初始值转化而来的结果。假设得到的结果 dp[N][Y] ，则该值为体积总和恰好等于 Y 的最大价值。
完全背包
问题介绍
与01背包的区别：所有物品可以无限件使用。其它都一样。
基本思路
跟01背包一样，一定需要一个for (int i = 1; i <= N; ++i)外层循环，枚举每个物品。内部循环相较于01背包需要发生呢个变化。需要枚举 v[i]~V 容量下，放置 1~k 个物品i，最大价值的情况，并记录进 dp 数组。因此直观思路是再套两层循环，如下所示。
for (int j = V; j >= v[i]; --j) {
for(int k=1;k*v[i]<=j;++k){
dp[j] = Math.max(dp[j], dp[j - k * v[i]] + w[i]);
}
}
实际上， k 的那一层循环是可以省略的。如下所示
完全背包解法：
private static void completeBackpack(int N, int V, int[] v, int[] w) {
int[] dp = new int[V + 1];
for (int i = 1; i <= N; ++i) {
for (int j = v[i]; j <= V; ++j) {
dp[j] = Math.max(dp[j], dp[j - v[i]] + w[i]);
}
}
System.out.println(dp[V]);
}
如上述代码所示，内层遍历 j 采用正向枚举即可节省一层循环。前文提到过，在01背包里，这样枚举是错误的，因为dp[i][] 会把 dp[i-1][] 覆盖掉。但在本问题中可以巧妙利用其“覆盖”的特性，缩减时间复杂度。覆盖的过程，实际上就是原有的 dp 值加一个 w[i] 。对于每一个 dp[j] 而言，需要考虑是在 dp[j - v[i]] 加一个物品 i 的价值，还是不加物品 i 继续沿用 dp[j] 。for (int j = v[i]; j <= V; ++j)这样循环，最多可以加 （V - v[i] + 1）次物品，由于物品 i 体积大于等于 1，所以物品 i 的添加次数不可能超过 （V - v[i]）/ 1 次，所以一定会遇到最优的情况。
涉及顺序的完全背包问题
即放入背包中的物品，顺序不同的序列被视为不同的组合，求满足target的总组合数。
例题：单词拆分，组合总和IV
思路
将前面完全背包问题解决方案中两层循环倒过来即可解决该问题，即把对容量的遍历放在外层，物品的循环放在内层。前文的循环方式相当于去除了重复的组合。
换种思路来理解：假设物品1~ n，对于每一个容量K而言（K<=target），要从前一步抵达K的位置，有1~ n种可能。假设某物品体积为v，对于容量（K-v）而言也同样是遍历过n个物品，所以应该在内层循环遍历n个物品，这样一定枚举了所有排列情况。
示例代码如下：
class Solution {
public int combinationSum4(int[] nums, int target) {
int[] dp = new int[target+1];
dp[0] = 1;
for(int j=1;j<=target;++j){
for(int item : nums){
if(j>=item) dp[j] += dp[j-item];
}
}
return dp[target];
}
}
多重背包
问题介绍
在完全背包基础上，对每个物品限定数量。
普通解法
import java.util.Scanner;
public class Main{
public static void main(String[] args) throws Exception{
Scanner reader = new Scanner(System.in);
int N = reader.nextInt();
int V = reader.nextInt();
int[] dp = new int[V + 1];
for(int i=1;i<=N;++i){
int v = reader.nextInt();
int w = reader.nextInt();
int s = reader.nextInt();
for(int j=V;j>=v;--j){
for(int k=1;k<=s&&k*v<=j;++k){
dp[j] = Math.max(dp[j],dp[j-k*v]+k*w);
}
}
}
System.out.println(dp[V]);
}
}
二进制优化方法
实际上，当s非常大时，将物品划分为s个物品，转化为01背包问题来计算，这样时间复杂度非常巨大。有一个技巧，可以简化该问题：对于任意一个数S，分成数量不同的若干个数，这些数选或不选可以拼成小于S的任意一个数。
如何划分这个S便是问题的关键。试想，对于一个数 7 它的二进制形式是 111 ，每一位上取 1 或者取 0 正好可以描述“选物品”或者“不选物品”两个行为，因此可以想到将 7 划分为 1 + 2 + 4。对于二进制位全为 1 的数，可以使用上述方法进行划分。如果不是这样的数，譬如说10，该如何划分呢？
实际上可以划分为 1 + 2 + 4 + 3。要证明此猜想，只需要证明7~10之间的数一定能通过1、2、4、3这四个数选或不选来得到即可。由于 1、2、4 一定能得到5、6、7，因此 +3 一定能得到 8、9、10，所以得证。
二进制优化方法的代码如下所示：
import java.util.Scanner;
import java.util.LinkedList;
import java.util.List;
public class Main{
public static void main(String[] args) throws Exception {
Scanner reader = new Scanner(System.in);
int N = reader.nextInt();
int V = reader.nextInt();
List<Integer> vList = new LinkedList<>();
List<Integer> wList = new LinkedList<>();
int[] dp = new int[V + 1];
for (int i = 0; i < N; ++i) {
int v = reader.nextInt();
int w = reader.nextInt();
int s = reader.nextInt();
for (int k = 1; k <= s; k *= 2) {
vList.add(k * v);
wList.add(k * w);
s -= k;
}
if (s > 0) {
vList.add(s * v);
wList.add(s * w);
}
}
for (int i = 0; i < vList.size(); ++i) {
int v = vList.get(i);
int w = wList.get(i);
for (int j = V; j >= v; --j) {
dp[j] = Math.max(dp[j], dp[j - v] + w);
}
}
System.out.println(dp[V]);
}
}
混合背包问题
描述：物品一共有三类，第一类物品只能用一次（01背包），第二类物品能用无限次（完全背包），第三类物品最多用s次（多重背包）
思路
将01背包、完全背包、二进制优化的多重背包三个算法都结合起来，遍历到每个物品的时候做一个判断即可。
- 遍历每一行输入，即每一类物品；
- 如果是物品只能选一次，按照01背包方法，更新dp数组（计算每一个容量下，选或不选的最大价值）；
- 如果物品可以选无数次，则按照完全背包方法，更新dp数组；
- 如果给定 s ，则将s按二进制分解为log(s)份，也按照01背包来计算。
具体的题目描述可参考混合背包问题，代码如下：
import java.util.Scanner;
public class Main{
public static void main(String[] args) throws Exception {
Scanner reader = new Scanner(System.in);
int N = reader.nextInt();
int V = reader.nextInt();
int[] dp = new int[V + 1];
for(int i=0;i<N;++i){
int v = reader.nextInt();
int w = reader.nextInt();
int s = reader.nextInt();
if(s == -1){// 01背包
dp_01(dp, V, v, w);
}else if(s == 0){ // 完全背包
for(int j=v;j<=V;++j){
dp[j] = Math.max(dp[j],dp[j-v]+w);
}
}else{ // 多重背包
for(int k=1;k<=s;s-=k,k*=2){
dp_01(dp, V, k*v, k*w);
}
if(s>0) dp_01(dp, V, s*v, s*w);
}
}
System.out.println(dp[V]);
}
private static void dp_01(int[] dp, int V, int v, int w){
for(int j=V;j>=v;--j){
dp[j] = Math.max(dp[j],dp[j-v]+w);
}
}
}
二维费用背包问题
每个物品有两个属性：体积和重量。在01背包的基础上，多加入了一个维度“重量”，即费用从一维扩展到二维。
思路
将dp数组设置为二维数组，分别代表体积和重量两个维度，跟01背包相比多了一层循环。代码如下：
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner reader = new Scanner(System.in);
int N = reader.nextInt();//物品数量
int V = reader.nextInt();//体积上限
int M = reader.nextInt();//重量上限
int[][] dp = new int[V+1][M+1];
for(int i=0;i<N;++i){
int v = reader.nextInt();//物品体积
int m = reader.nextInt();//物品重量
int w = reader.nextInt();//物品价值
for(int j=V;j>=v;--j){
for(int k=M;k>=m;--k){
dp[j][k] = Math.max(dp[j][k],dp[j-v][k-m]+w);
}
}
}
System.out.println(dp[V][M]);
}
}
分组背包问题
输入物品有 N 个组，每一组中只能选择一个物品。
思路
依然是在01背包的基础上做改动。每次选择时，假设组内有S个物品，则有S+1种决策，遍历这些决策，选取价值最大的即可。代码如下所示：
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner reader = new Scanner(System.in);
int N = reader.nextInt();
int V = reader.nextInt();
int[] dp=new int[V+1];
for(int i=0;i<N;++i){
int s = reader.nextInt();
int[] v = new int[s];
int[] w = new int[s];
for(int k=0;k<s;++k){
v[k] = reader.nextInt();
w[k] = reader.nextInt();
}
for(int j=V;j>0;--j){
for(int k=0;k<s;++k){
if(j>=v[k])
dp[j] = Math.max(dp[j],dp[j-v[k]]+w[k]);
}
}
}
System.out.println(dp[V]);
}
}