背包问题总结分析

背包问题是个很经典的动态规划问题，本博客对背包问题及其常见变种的解法和思路进行总结分析

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 vList = new LinkedList<>();

List 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

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

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

int s = reader.nextInt();

int[] v = new int[s];

int[] w = new int[s];

for(int k=0;k

v[k] = reader.nextInt();

w[k] = reader.nextInt();

}

for(int j=V;j>0;--j){

for(int k=0;k

if(j>=v[k])

dp[j] = Math.max(dp[j],dp[j-v[k]]+w[k]);

}

}

}

System.out.println(dp[V]);

}

}

程序员灯塔

转载请注明原文链接：【数据结构与算法】背包问题总结梳理