HDU 2602 Bone Collector (01背包问题 基础)

题目链接：HDU 2602 Bone Collector

题目描述：

输入 T 代表 T组数据， 每组数据一共3行，第一行输入n 和 m ，分别代表可选择物品的数量和背包的大小

接下来两行每行 n 个数字， 第一行数字代表每个物品的价值，第二行代表每个物品的体积。

问，给定背包能装物品的最大价值是多少。

Sample Input

1
5 10
1 2 3 4 5
5 4 3 2 1

Sample Output

14

如样例 ， 选择第 2 ，3 ，4 ，5 个物品正好装满背包，总价值为 14，为最大的情况。

算法分析

我们用 value[ i ]储存每个物品的价值，用vol[ i ]储存每个物品的体积 （i >= 1） ，

引入dp[ i ][ j ], 代表把前 i 个物品装到容量为 j 的背包中的最大价值。 

01背包的特点就是：每种物品仅有一件，可以选择放或不放。

所以状态转移方程为 dp[ i ][ j ] = max( dp[ i - 1 ][ j ] , dp[ i - 1 ][ j - vol[ i ]  + value[ i ]);

这个方程其实不难理解 ， 就是当前背包中最大价值 等于 （不放第 i 件物品 和 放第 i 件物品 这两者的最大值）

这里可能对 dp[ i - 1 ][ j - vol[ i ]  + value[ i ]  有疑惑， i - 1 代表上一层的状态， 由于上一层我们 将 容量 0 ~ｍ的状态全部计算了出来，所以可以利用

dp[ i - 1 ][ j - vol[ i ] ] 就代表了上一层状态中 背包容量为 j - vol[ i ] 时所能容纳的最大价值，然后在加上 value[ i ]， 也就是当前物品的最大价值。

这样我们从第一件物品的放或不放， 一直计算到第n件物品，所以结果就是 dp[ n ][ m ].

空间优化

这里有一个对空间的优化版本，我们还可以把dp数组变成 1 维的。

直接给出代码

memset(DP,0,sizeof(DP));
for(int i=1;i<=n;i++)
	for(int j=m;j>=0;j--){
		if(j>=vol[i])
			DP[j] = max(DP[j],DP[j-vol[i]] + value[i]);
	}
printf("%d\n",DP[m]);

为什么这么做可以呢？ 注意看for循环的计算顺序，DP数组是从上到下，从右向左计算的。计算dp[ i ][ j ]之前，DP[ j ]中保存的就是 dp[ i - 1 ][ j ] ,

而 DP[ j - vol [i] ] ,储存的就是dp[ i - 1 ][ j - w ] ,而不是 dp [ i ][ j - w ]， 因为 我们的 j 是逆序枚举的， 此时 dp [ i ][ j - w ]还没有算出来  。

这样 ， 用一维数组就能储存上一层的状态了。

源代码

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxn = 1010;
int value[maxn];
int vol[maxn];
int dp[maxn][maxn];
int DP[maxn];
int main(){
	int t;
	scanf("%d",&t);
	while(t--){
		int n,m;
		scanf("%d%d",&n,&m);
		memset(dp,0,sizeof(dp));
		for(int i=1;i<=n;i++)
			scanf("%d",&value[i]);
		for(int i=1;i<=n;i++)
			scanf("%d",&vol[i]);
		for(int i=1;i<=n;i++){
			for(int j=0;j<=m;j++){ //vol容量可能为0； j 的顺序无所谓
				if(j>=vol[i])
					 dp[i][j] = max(dp[i-1][j] , dp[i-1][j-vol[i]] + value[i]);
				else
					dp[i][j] = dp[i-1][j];
			}
		}
		// for(int i=0;i<=n;i++){ //可以打印出来看看手动模拟下
			// for(int j=0;j<=m;j++)
				// printf("%d ",dp[i][j]);
			// printf("\n");
		// }
		printf("%d\n",dp[n][m]);
		// memset(DP,0,sizeof(DP)); //空间优化方法
		// for(int i=1;i<=n;i++)
			// for(int j=m;j>=0;j--){ j的顺序必须从后往前
				// if(j>=vol[i])
					// DP[j] = max(DP[j],DP[j-vol[i]] + value[i]);
			// }
		// printf("%d\n",DP[m]);
	}
	return 0;
}

第一种方法还有一种与之“对称”的状态定义 用 dp [ i ][ j ]，表示把  i , i + 1 , i + 2 , , , n 装入容量为 j 的   背包中的最大价值

显然 外层循环需要从 n ~１，而最后的答案为　dp [ 1 ][ m ]

memset(dp,0,sizeof(dp));
for(int i=n;i>=1;i--){
	for(int j=0;j<=m;j++){
		if(j>=vol[i])
			dp[i][j] = max(dp[i+1][j] , dp[i+1][j-vol[i]] + value[i]);
		else
			dp[i][j] = dp[i+1][j];
	}
}
printf("%d\n",dp[1][m]);

转载于:https://www.cnblogs.com/chaiwenjun000/p/5321148.html