结果为时两天的折磨,对背包问题小有感悟:
题目 2131: 信息学奥赛一本通T1267-01背包问题
时间限制: 1s 内存限制: 128MB 提交: 1225 解决: 555
题目描述
一个旅行者有一个最多能装 M 公斤的背包,现在有 n 件物品,它们的重量分别是W1,W2,...,Wn,它们的价值分别为C1,C2,...,Cn,求旅行者能获得最大总价值。
输入格式
第一行:两个整数,M(背包容量,M≤200)和N(物品数量,N≤30);
第2..N+1行:每行二个整数Wi,Ci,表示每个物品的重量和价值。
输出格式
仅一行,一个数,表示最大总价值。
样例输入 复制
10 42 13 34 57 9
也许大家和我一样有个疑问,为什么要叫01背包,熟读问题三遍以上,我们便会发现,取物只有两种状态,也即是“取1”或者“不取0”。
如果将背包大小从小到大遍历,就会得到这样一个:
![](https://i-blog.csdnimg.cn/blog_migrate/39e2ba3bd3fd4abcc4941b3d59268226.png)
1、第一个条件就是:我要背包大小大于这个物品的大小,我才能拿
2、第二个是:我拿了的价值大,还是我上一个的最大价值大,并且我拿了这个值,还剩下的空间大小它的最大值加上。
定义dp[i][j]的含义,这一点也是动态规划中比较繁琐的,我们知道,一定要把一个物品的0-n所有背包大小都遍历一遍,所以背包大小要在里层循环即为j,那么i就是某个背包:
即:dp[i][j]为物品为i时,背包大小为j时的最大价值。
所以推导算式就是:
dp[i][j]=最大值((上一个最大值)dp[i-1][j],(拿当前物品,背包减去当前物品重量剩下的最大值)dp[i-1][j-w[i]]+v[i](加上当前价值))
不能拿就使用上一个的最大价值dp[i-1][j];
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int big = sc.nextInt();
int n = sc.nextInt();
int[] w = new int[n + 1];
int[] v = new int[n + 1];
int[][] dp = new int[n + 1][big + 1];
for (int i = 1; i <= n; i++) {
w[i] = sc.nextInt();
v[i] = sc.nextInt();
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= big; j++) {
if (j >= w[i]) {
dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - w[i]] + v[i]);
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
System.out.println();
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= big; j++) {
System.out.printf("%4d", dp[i][j]);
}
System.out.println();
}
}
}
所以我们总结就是:所以这个就是拿不拿,怎么拿的问题,即:背包大于当前物品大小,拿了后加上剩下空间的值(剩下空间的值一定能够在以往的步骤中找到,因为当前背包减去物品大小,是等于另一个背包大小。因为只能拿一次)。
也可以倒着算,先使用最大的背包,越来越小:
![](https://i-blog.csdnimg.cn/blog_migrate/1c01f4a3cfb7d481505eddcfceb812e1.png)
当然你输出的时候是一样的,没啥区别:
![](https://i-blog.csdnimg.cn/blog_migrate/3df5dadd8f62996b38989dcb81ea2160.png)
前面我们使用的是二位数组,我们发现:如果不能取,就得使用上一个物品的最大价值,
也就是dp[i-1][j],只是i变了,j没有变,所以我们是能使用一维数组来做的:
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int big = sc.nextInt();
int n = sc.nextInt();
int[] w = new int[n + 1];
int[] v = new int[n + 1];
// int[][] dp = new int[n + 1][big + 1];
int[] dp = new int[big + 1];
for (int i = 1; i <= n; i++) {
w[i] = sc.nextInt();
v[i] = sc.nextInt();
}
for (int i = 1; i <= n; i++) {
for (int j = big; j >= 1; j--) {
if (j >= w[i]) {
dp[j] = Math.max(dp[j], dp[j - w[i]] + v[i]);
} else {
// 因为只有一行的原因,上一行的数据任然保存在当前位置中
// 所以很多博主并没有写上这句话,但是我们递推的时候,是有这一个程序的!
dp[j] = dp[j];
}
}
System.out.println(Arrays.toString(dp));
}
}
}
01背包的问题便是这样,需要大家一步一步推理,想法与问题很简单,主要是动态规划的思想。
接下来提升一下难度,如下:
设有n种物品,每种物品有一个重量及一个价值。但每种物品的数量是无限的,同时有一个背包,最大载重量为M,今从n种物品中选取若干件(同一种物品可以多次选取),使其重量的和小于等于M,而价值的和为最大。
输入格式
第一行:两个整数,M(背包容量,M≤200)和N(物品数量,N≤30);
第2..N+1行:每行二个整数Wi,Ci,表示每个物品的重量和价值。
输出格式
仅一行,一个数,表示最大总价值。
样例输入
10 42 13 34 57 9
样例输出
max=12
也就是物品无限使用的背包,
首先想取物品取法
当前背包大小,能够取几个当前物品,没装满的话,剩余的寻找以往的最大值(既然装不下,就说明有一个比当前更小的背包大小)。
和01背包的区别就是,能够装多少当前物品。
取了n个物品,重量就是n*当前物品重量,价值也是如此n*当前物品的价值。
循环0-背包大小/当前物品大小,也就是最大装当前物品k。
所以只需要在01背包的基础上,小改一下:(一维数组)
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 10 4
// 2 1
// 3 3
// 4 5
// 7 9
int big = sc.nextInt();
int n = sc.nextInt();
int[] w = new int[n + 1];
int[] v = new int[n + 1];
for (int i = 1; i <= n; i++) {
w[i] = sc.nextInt();
v[i] = sc.nextInt();
}
int[] dp = new int[big + 1];
for (int i = 1; i <= n; i++) {
for (int j = big; j >= 1; j--) {
for (int k = 0; k <= j / w[i]; k++) {
// 第k个装不下了
if (k * w[i] <= j) {
dp[j] = Math.max(dp[j], dp[j - k * w[i]] + k * v[i]);
} else {
// 这一步虽然很鸡肋,但是,有这一步,便于理解
dp[j] = dp[j];
break;
}
}
}
System.out.println(Arrays.toString(dp));
}
System.out.println("max="+dp[big]);
}
}
二维数组版本:
推到一遍,为什么用一二维数组都可以完成。
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 10 4
// 2 1
// 3 3
// 4 5
// 7 9
int big = sc.nextInt();
int n = sc.nextInt();
int[] w = new int[n + 1];
int[] v = new int[n + 1];
for (int i = 1; i <= n; i++) {
w[i] = sc.nextInt();
v[i] = sc.nextInt();
}
int[][] dp = new int[n + 1][big + 1];
for (int i = 1; i <= n; i++) {
for (int j = big; j >= 1; j--) {
for (int k = 0; k <= j / w[i]; k++) {
// 第k个装不下了
if (k * w[i] <= j) {
dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - k * w[i]] + k * v[i]);
} else {
// 这一步虽然很鸡肋,但是,有这一步,便于理解
dp[i][j] = dp[i - 1][j];
break;
}
}
}
}
// for (int i = 0; i <=n; i++) {
// for (int j = 0; j <=big; j++) {
// System.out.print(dp[i][j]+" ");
// }
// System.out.println();
// }
System.out.println("max=" + dp[n][big]);
}
}
另外一个便是多重背包问题:
为了庆贺班级在校运动会上取得全校第一名成绩,班主任决定开一场庆功会,为此拨款购买奖品犒劳运动员。期望拨款金额能购买最大价值的奖品,可以补充他们的精力和体力。
输入格式
第一行二个数n(n≤500),m(m≤6000),其中n代表希望购买的奖品的种数,m表示拨款金额。
接下来n行,每行3个数,v、w、s,分别表示第I种奖品的价格、价值(价格与价值是不同的概念)和能购买的最大数量(买0件到s件均可),其中v≤100,w≤1000,s≤10。
输出格式
一行:一个数,表示此次购买能获得的最大的价值(注意!不是价格)。
样例输入
5 100080 20 440 50 930 50 740 30 620 20 1
样例输出
1040
就是物品取的次数指定,这个就更好理解了:
就是0到n,每次取的时候判断到底取多少更大,
import java.util.*;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int big = sc.nextInt();
int[] w = new int[n + 1];
int[] v = new int[n + 1];
int[] s = new int[n + 1];
for (int i = 1; i <= n; i++) {
w[i] = sc.nextInt();
v[i] = sc.nextInt();
s[i] = sc.nextInt();
}
int[] dp = new int[big + 1];
for (int i = 1; i <= n; i++) {
for (int j = big; j >= 1; j--) {
for (int k = 0; k <=s[i]; k++) {
if(j>=k*w[i]) {
dp[j]=Math.max(dp[j], dp[j-k*w[i]]+k*v[i]);
}else {
dp[j]=dp[j];
break;
}
}
}
}
System.out.println(dp[big]);
}
}
以上代码都是按照简单思想实现的,另一种完全背包不好理解。
期间很折磨,但是收益颇丰啊!