✨哈喽，进来的小伙伴们，你们好耶！✨
🛰️🛰️系列专栏:【蓝桥杯专项】
✈️✈️本篇内容:动态规划_背包问题合集！
🚀🚀码云仓库gitee：Java数据结构代码存放!
⛵⛵作者简介：一名双非本科大三在读的科班Java编程小白，道阻且长，你我同行！
注：每个题的标题就是原题链接
一、完全背包问题
问题描述
有 N 种物品和一个容量是 V
的背包，每种物品都有无限件可用。
第 i种物品的体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。
输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。
接下来有 N行，每行两个整数 vi,wi，用空格隔开，分别表示第 i种物品的体积和价值。
输出格式
输出一个整数，表示最大价值。
数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 5
输出样例：
10
思路分析：在上篇博客博主就已经介绍了0/1背包问题，那么完全背包问题跟0/1背包问题的区别就是它考虑前i个物品每个物品可以被多次选择。 那么，老规矩，我们根据状态规划可以得到：
(朴素解法)
1、曲线救国，去掉k个物品i
2、求max：f[i-1,j-k*v[i]]
3、在加回来k个物品i
由此得到我们的状态转移方程为：f[i-1,j-v[i] * k] + k*w[i]
代码实现：
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int [] v = new int[1001];
int [] w = new int[1001];
int [][] f = new int[n+1][m+1];
for (int i = 1; i <= n; i++) {
v[i] = sc.nextInt();
w[i] = sc.nextInt();
}
for (int i = 1; i <=n ; i++) {
for (int j = 0; j <=m ; j++) {
for (int k = 0; k * v[i] <=j ; k++) {
f[i][j] = Math.max(f[i][j],f[i-1][j-v[i] * k]+ k * w[i]);
}
}
}
System.out.println(f[n][m]);
sc.close();
}
}运行结果：
我们可以发现运行时间非常的慢，那么什么原因呢？一方面是因为Java语言实现数据结构本身就比较慢，可以看到我们的代码是通过了3层循环来实现，最坏情况下时间复杂度是(n * v^2)，时间复杂度很高，那么是否可以优化该背包问题的代码呢？
优化一：
通过比较0/1背包问题，通过f[i,j] 和 f[i,j-v] 的递推公式我们可以发现，若要求得f[i,j-v]的最大值，只需要求出f[i,j]的最大值在加上一个w[i]即可，具体如下：
代码实现：
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int [] v = new int[1001];
int [] w = new int[1001];
int [][] f = new int[n+1][m+1];
for (int i = 1; i <= n; i++) {
v[i] = sc.nextInt();
w[i] = sc.nextInt();
}
for (int i = 1; i <=n ; i++) {
for (int j = 0; j <=m ; j++) {
f[i][j] = f[i-1][j];
if(j>=v[i]) f[i][j] = Math.max(f[i][j],f[i][j-v[i]]+w[i]);
}
}
System.out.println(f[n][m]);
sc.close();
}
}运行结果：
我们发现快了整整2000ms，因为优化后的代码少了一层循环，还是很可观的。
优化二、转换为一维数组来实现
代码实现：
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int [] v = new int[1001];
int [] w = new int[1001];
int [] f = new int[m+1];
for (int i = 1; i <= n; i++) {
v[i] = sc.nextInt();
w[i] = sc.nextInt();
}
for (int i = 1; i <=n ; i++) {
for (int j = v[i]; j <=m ; j++) {
f[j] = Math.max(f[j],f[j-v[i]]+w[i]);
}
}
System.out.println(f[m]);
sc.close();
}
}注意我们这里的j是从v[i]开始的，即从小到大，与0/1背包问题不同的是0/1背包问题是从大到小,
for (int i = 1; i <=n ; i++) {
for (int j = m; j >= v[i] ; j--) {
f[j] = Math.max(f[j],f[j-v[i]]+w[i]);
}
}原因：简单来说，一维情况正序更新状态f[j]需要用到前面计算的状态已经被「污染」，逆序则不会有这样的问题。
二、多重背包问题
问题描述
有 N 种物品和一个容量是 V的背包。
第 i种物品最多有 si 件，每件体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。
输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。
接下来有 N行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i种物品的体积、价值和数量。
输出格式
输出一个整数，表示最大价值。
数据范围
0<N,V≤100
0<vi,wi,si≤100
输入样例
4 5
1 2 3
2 4 1
3 4 3
4 5 2
输出样例：
10
思路：我们可以模仿完全背包问题的朴素解法直接写出代码：
import java.util.*;
public class Main{
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int [] v = new int[101];
int [] w = new int[101];
int [] s = new int[101];
int [][] f = new int[n+1][m+1];
for (int i = 1; i <= n; i++) {
v[i] = sc.nextInt();
w[i] = sc.nextInt();
s[i] = sc.nextInt();
}
for (int i = 1; i <=n ; i++) {
for (int j = 0; j <=m ; j++) {
for (int k = 0; k<=s[i] && k * v[i] <=j; k++) {
f[i][j] = Math.max(f[i][j],f[i-1][j-v[i] * k]+ k * w[i]);
}
}
}
System.out.println(f[n][m]);
}
}运行结果：
那么如果题目给的n,v,s的比较大的话，暴力解法接不能通过了，这就需要我们考虑如何来进行优化。
二进制优化：
博主对于本题的二进制优化也是第一次接触到，通过查阅了不少资料并且反复观看了讲解视频后的个人总结心得：
1、在完全背包中,我们可以通过两个状态转移方程：
f[i,j]=max(f[i−1,j],f[i−1,j−v]+w,f[i−1,j−2v]+2w,f[i−1,j−3v]+3w,.....)
f[i,j−v]=max(f[i−1,j−v],f[i−1,j−2v]+w,f[i−1,j−2v]+2w,.....)
最后推导出-> f[i][j]=max(f[i−1][j],f[i][j−v]+w)。
2、在多重背包中，我们的推导过程为：
f[i,j] = max(f[i−1,j],f[i−1,j−v]+w,f[i−1,j−2v]+2w,.....f[i−1,j−Sv]+Sw,)
f[i,j−v]= max(f[i−1,j−v],f[i−1,j−2v]+w,.....f[i−1,j−Sv]+(S−1)w,f[i−1,j−(S+1)v]+Sw)
我们可以发现f[i,j−v]的最后一项比f[i,j]多出来一项，这就令人很是难受，对于完全背包问题我们直接对求的结果在加上个w[i]便可求出最大值，那么对于本题我们首先要了解一点：
怎么比完全背包方程比较就多出了一项?
其实，一般从实际含义出发来考虑即可，这里是在分析f[i,j−v]这个状态的表达式，首先这个状态的含义是 从前i个物品中选，且总体积不超过(j-v)的最大价值， 我们现在最多只能选s个物品，因此如果我们选s个第i个物品，那么体积上就要减去 s∗v,价值上就要加上s∗w，那更新到状态中去就是 f[i−1,j−v−s∗v]+s∗w，提取公因式v，也就是f[i−1,j−(S+1)v]+Sw。
什么是二进制优化？
简单来说就是比如系统给出一个数1023，那么按照常规惯例一个一个枚举我们是不是要枚举1023次才能得到这个结果，那么二进制优化是怎么做的呢？比如1023，那么我们可以通过2^0,2^1,2^2 ……2^k，这里的k应该是9，为什么是9呢，因为用2^0~2^9之间的数字拼凑可以任意用来表示1~1023之间的任何数字，这样就大大减少了我们的枚举数量，也就是一个时间复杂度从Si -> logSi的一个提高，这里我参照了网上的一个特别有意思的案列，可以根据这个案列来理解：
原地址：二进制优化思维
二进制优化思维就是：现在给出一堆苹果和10个箱子，选出n个苹果。将这一堆苹果分别按照1,2,4,8,16,.....512分到10个箱子里，那么由于任何一个数字x∈[0,1023] (第11个箱子才能取到1024，评论区有讨论这个)都可以从这10个箱子里的苹果数量表示出来，但是这样选择的次数就是 ≤10次。
比如：
如果要拿1001次苹果，传统就是要拿1001次；二进制的思维，就是拿7个箱子就行（分别是装有512、256、128、64、32、8、1个苹果的这7个箱子）,这样一来，1001次操作就变成7次操作就行了。
这样利用二进制优化，时间复杂度就从 O(n^3)
降到O(n^2*logS),从4∗10^9降到了2∗10^7。
代码实现：
import java.util.Scanner;
public class Main {
/** 多重背包问题
*
*/
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int [] v = new int[25000];
int [] w = new int[25000];
int [] f = new int[25000];
int count = 0;//用来表示还剩几种物品
int a,b,s,k = 1;
//k就相当于每次多少个物品
for (int i = 1; i <= n ; i++) {
a = sc.nextInt();//体积
b = sc.nextInt();//价值
s = sc.nextInt();//数量
while(k<=s){
count++;
v[count] = a*k;
w[count] = b*k;
s -= k;
k *= 2;
}
if(s>0){//如果还有多余空间
count++;
v[count] = a*s;
w[count] = b*s;
}
}
n = count;//重置count
for (int i = 1; i <= n ; i++) {//这里写一遍0/1背包一维实现便可
for (int j = m; j >=v[i] ; j--) {
f[j] = Math.max(f[j],f[j-v[i]]+w[i]);
}
}
System.out.println(f[m]);
}
}
三、分组背包问题
问题描述
有 N 组物品和一个容量是 V的背包。
每组物品有若干个，同一组内的物品最多只能选一个。
每件物品的体积是 vij，价值是 wij，其中 i 是组号，j是组内编号。
求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。输出最大价值。
输入格式
第一行有两个整数 N，V，用空格隔开，分别表示物品组数和背包容量。
接下来有 N组数据：
- 每组数据第一行有一个整数 Si，
- 表示第 i个物品组的物品数量；
- 每组数据接下来有 Si行，每行有两个整数 vij,wij，用空格隔开，分别表示第 i 个物品组的第 j个物品的体积和价值；
- 输出格式
-
输出一个整数，表示最大价值。
数据范围
0<N,V≤100
0<Si≤100
0<vij,wij≤100 -
输入样例
3 5 2 1 2 2 4 1 3 4 1 4 5输出样例：
8
思路非常简单，首先读懂题目，然后根据题意，朴素解法就可。
代码实现：
import java.util.*;
class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int maxV = 105;
int maxN = 105;
int N, M, V;
int[] dp = new int[maxV];
int[] v = new int[maxN];
int[] w = new int[maxN];
N = sc.nextInt(); V = sc.nextInt();
for (int i = 0; i < N; i++) {
M = sc.nextInt();
for (int j = 0; j < M; j++) {
v[j] = sc.nextInt();
w[j] = sc.nextInt();
}
for (int j = V; j >= 0; j--) {
for (int k = 0; k < M; k++) {
if (j >= v[k]) dp[j] = Math.max(dp[j], dp[j - v[k]] + w[k]);
}
}
}
System.out.println(dp[V]);
}
}
