【动态规划】01背包及其优化详解

题目描述

有N件物品和一个容量为V的背包。放入第i件物品耗费的空间是Ci，得到的价值是Wi。求解在不超过容量的前提下，将哪些物品装入背包可使价值总和最大。

输入格式

第1行两个正整数，分别表示N和V，中间用一个空格隔开。
第2行N个正整数，表示Ci，中间用一个空格隔开。
第3行N个正整数，表示Wi，中间用一个空格隔开。
其中：1≤N≤100，1≤V≤106，1≤Ci≤10000，1≤Wi≤10000。

输出格式

一行一个正整数，表示最大的价值总和。

样例输入

4 20
8 9 5 2
5 6 7 3

样例输出

16

基本思路：动态规划

1.状态与定义

状态1：【面对前i个物品】
缺少该状态可能会导致某个物品被重复选择
状态2：当前【剩余的空间j】
很明显，没有剩余空间无法确定某个物品是否能被选择

---

总结: dp[ i ][ j ]:面对前i个物品，且剩余空间为j时的最大价值

2.状态转移方程

对于第i个物品只有选择与不选择两种情况
选择：
如果剩余空间大于等于该物品占用的空间则可以选择
若选择要保证前i个物品的最大价值，应该在前i-1个物品最大价值的基础上增加该物品的价值，且空间减少对应物品的体积：
dp[ i ][ j ] = dp[i-1][ j- c[i] ]+w[i]

---

不选择:
不选择第i个物品则代表第i个物品对最大价值没有影响，面向前i个物品的最大价值与面向前i-1个物品的最大价值一致
dp[i][j] = dp[ i-1][ j ]

---

总结：
选与不选取大者即可
dp[ i ] [ j ] = max(dp [ i-1] [ j-c[i] ]+w[i],dp [ i-1][ j ])

3.初值

初值全都为0即可

代码0：

/***
动态规划二维数组版： 
1.状态:
	状态1：前i个物品 
	状态2：背包的空间j
	dp[i][j]: 面对前i个物品且空间为j时能装的最大价值物品 
2.方程 
	dp[i][j] = max(dp[i-1][j-C[i]]+W[i],dp[i-1][j]); 
3.初值
	dp[i][j] = 0
	 
**/

#include <bits/stdc++.h>
#define maxlen 1005

using namespace std;
int n,v;
int c[102];
int w[102];
int dp[102][int(1e6+2)];

int main() {

	cin>>n>>v;
	
	for(int i = 1 ;i<=n ;i++){
		cin>>c[i];
	}
	
	for(int i = 1 ;i<=n ;i++){
		cin>>w[i];
	}
	
	for(int i = 1 ;i<=n; i++){
		for(int j = 1; j<=v ;j++)
		{
			//默认先不选择第i个物品 
			dp[i][j] = dp[i-1][j];
			//可以选择的情况下，比较选与不选的大小 
			if(j-c[i]>=0)
				dp[i][j] = max(dp[i-1][j-c[i]]+w[i],dp[i][j]);
		}		
	}
	
	for(int i = 1 ;i<=n ;i++){
		for(int j = 1; j<=v ;j++) 
			cout<<dp[i][j]<<" ";
		cout<<endl;
	}
	
	cout<<dp[n][v]<<endl; 
   return 0;
}

改进1

实际上，由状态转移方程
dp[ i ] [ j ] = max(dp [ i-1] [ j-c[i] ]+w[i],dp [ i-1][ j ])
和dp二维数组的值很容易发现：

  |1  2  3  4  5  6  7  8  9  10 11 12 13 14 15 16 17 18 19 20
——|————————————————————————————————————————————————————————————
1 |0  0  0  0  0  0  0  5  5  5  5  5  5  5  5  5  5  5  5  5
2 |0  0  0  0  0  0  0  5  6  6  6  6  6  6  6  6  11 11 11 11
3 |0  0  0  0  7  7  7  7  7  7  7  7  12 13 13 13 13 13 13 13
4 |0  3  3  3  7  7  10 10 10 10 10 10 12 13 15 16 16 16 16 16

第i行的数据只依赖于第i-1行的值，因此我们只需保存第i-1行和第i行这两行的值即可，即两个一维数组dp1[]和dp2[]
dp1[ j ] 等价于 dp[i-1] [ j ]
dp2[ j ] 等价于 dp[ i ] [ j ]
新的方程：dp2[j] = max(dp1[j-c[i]]+w[i],dp2[j])

代码1

/**
动态规划 双一维数组版：
4 20
8 9 5 2
5 6 7 3
0  0  0  0  0  0  0  5  5  5  5  5  5  5  5  5  5  5  5  5
0  0  0  0  0  0  0  5  6  6  6  6  6  6  6  6  11 11 11 11
0  0  0  0  7  7  7  7  7  7  7  7  12 13 13 13 13 13 13 13
0  3  3  3  7  7  10 10 10 10 10 10 12 13 15 16 16 16 16 16
16
由dp数组和方程可知，实际上每次只涉及到两行数据，第i的数据只依赖于i-1行 
因此可以利用两个一维数组，分别保存第i-1行和第i行的数据 
**/
 

#include <bits/stdc++.h>
#define maxlen 1005

using namespace std;
int n,v;
int c[102];
int w[102];
//保存第i-1行的数据 
int dp1[int(1e6+2)];
//保存第i行的数据 
int dp2[int(1e6+2)];
int main() {

	cin>>n>>v;
	
	for(int i = 1 ;i<=n ;i++){
		cin>>c[i];
	}
	
	for(int i = 1 ;i<=n ;i++){
		cin>>w[i];
	}
	//dp1[j] : dp[i-1][j] 
	//dp2[j] : dp[i][j]
	for(int i = 1; i<=n;i++){
		for(int j = 1 ;j<=v ;j++){
			dp2[j] = dp1[j];
			if(j-c[i]>=0)
				dp2[j] = max(dp1[j-c[i]]+w[i],dp2[j]);
		}
		//将dp2赋给dp1,保存上一行的值 
		for(int k = 1 ;k<=v ;k++)
			dp1[k] = dp2[k];
	}
	cout<<dp2[v]<<endl;
	//或
	//cout<<dp1[v]<<endl;
   return 0;
}

改进2：

由状态转移方程：dp[i][j] = max(dp[i-1][j-c[i]]+w[i],dp[i-1][j-1])
或 dp2[j] = max(dp1[j-c[i]]+w[i],dp1[j]) 进一步发现

---

第i行数据更新的时候是按照列(空间)从小到大的顺序，如果在原地更新
这种方式会导致数组中列数小的数据被覆盖掉。

---

如果对列按照从大到小的顺序进行枚举，则列数大的数据得到了更新，
尽管列数序小的数据被用来更新列数大的数据，但没有被破坏。
利用这个特点，我们可以将dp1[]和dp2[]两个一维数组用一个dp[]来表示.
新的方程为：dp[j] = max(dp[j-c[i]]+w[i],dp[j]),但j从v到0

例如:以第2行的生成为例：首先使用dp[]存储第1行的数据
（由于第1行生成时数组的初值都为0，无法体现原地生成数据的过程，因此这里假设已经生成了第1行）

---

i = 1时：
0 dp[]: 0 0 0 0 0 0 0 5 5 5 5 5 5 5 5 5 5 5 5 5

i = 2 , j = v:
dp[v] = dp[v-c[2]]+w[2] = dp[11]+6 = 11
1 dp[]: 0 0 0 0 0 0 0 5 5 5 5 5 5 5 5 5 5 5 5 11
----------------------------------------------------------^

i = 2 , j = v-1
dp[v-1] = dp[v-1-c[2]]+w[2] = dp[10]+6 = 11
2 dp[]: 0 0 0 0 0 0 0 5 5 5 5 5 5 5 5 5 5 5 11 11
-------------------------------------------------------^

i = 2 , j= v-2
dp[v-2] = dp[v-2-c[2]]+w[2] = dp[9]+6 = 11
3 dp[]: 0 0 0 0 0 0 0 5 5 5 5 5 5 5 5 5 5 11 11 11
----------------------------------------------------^

i = 2 , j =v-3
dp[v-3] = dp[v-3-c[2]]+w[2] = dp[8]+6 = 11
4 dp[]: 0 0 0 0 0 0 0 5 5 5 5 5 5 5 5 5 11 11 11 11
--------------------------------------------------^

i = 2 , j = v-4
dp[v-4] = dp[v-4-c[2]]+w[2] = dp[7]+6 = 6
5 dp[]: 0 0 0 0 0 0 0 5 5 5 5 5 5 5 5 6 11 11 11 11
-----------------------------------------------^

以此类推，可以观察到，当j逆序枚举时即使在原地生成下一列的数据，也不会丢失任何信息

代码2：

#include <bits/stdc++.h>
#define maxlen 1005

using namespace std;
int n,v;
int c[102];
int w[102];
int dp[int(1e6+2)];
int main() {

	cin>>n>>v;
	
	for(int i = 1 ;i<=n ;i++){
		cin>>c[i];
	}
	
	for(int i = 1 ;i<=n ;i++){
		cin>>w[i];
	} 
	for(int i = 1; i<=n;i++){
		//注意：逆序枚举 
		for(int j = v ;j>=0 ;j--){
			if(j-c[i]>=0)
				dp[j] = max(dp[j-c[i]]+w[i],dp[j]);
		}
	}
	cout<<dp[v]<<endl;
   return 0;
}