动态规划解决背包问题（一）01背包问题

1.可回溯的二维数组

对于有限数量的物品，可用建立dp[i][j]二维数组的方式,这里dp[i][j]表示当前背包容量为j且有i个物品的时候的最大价值，这种方法优点在于可以通过回溯找到每个物品是否放入，缺点是和滚动优化相比占用更多空间。

递推关系式：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w[i]] + p[i])

例题：

动态规划解决0/1背包问题

现有n种物品，对1<=i<=n，第i种物品的重量为正整数wi​，价值为正整数pi​，背包能承受的最大载重量为正整数M，要求找出这n种物品的一个子集，使得子集中物品的总重量不超过M且总价值尽量大。0/1背包问题要求物品或者整件装入背包中，或者根本不装入(即不能装入物品的一部分)，所以xi​限定只能取值0或1。

输入格式:

第1行是M和n，表示背包容量为M且有n件物品；

第2行是这n件物品的重量wi​；

第3行是各物品的价值pi​，背包容量和物品重量都为整数。

输出格式:

第1行是所选物品的价值之和，以及重量之和；

第2行是各物品装入背包的量，即xi​值。

输入样例1:

6 3
2 3 4
1 2 5

输出样例1:

6 6
1 0 1

输入样例2:

100 10
13 2 10 50 1 28 37 32 30 46 
12 23 37 45 19 11 25 9 14 18

输出样例2:

149 100
0 1 1 1 1 0 1 0 0 0

 答案代码：

#include<iostream>
using namespace std;

int max(int a, int b) {
	if (a > b)
		return a;
	else return b;
}

int w[10000];
int p[10000];
int dp[10000][10000] = { 0 };
int x[10000];        //表示物品i为0或者1
int M, n;
int endM=0;        //计算总重量

void DP() {
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= M; j++) {
			if (j < w[i])            //当前容量过小，故选择不放
				dp[i][j] = dp[i - 1][j];
			else                    //选择放入的情况
				dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - w[i]] + p[i]);
		}
	}
}

void Find(int i, int j) {        //回溯查找路径
	if (i >= 0) {
		if (dp[i][j] == dp[i - 1][j]) {
			x[i] = 0;
			Find(i - 1, j);
		}
		else if (j - w[i] >= 0 && dp[i][j] == dp[i - 1][j - w[i]] + p[i]) {
			x[i] = 1;
			endM=endM+w[i];
			Find(i - 1, j - w[i]);
		}
	}
}


int main()
{
	cin >> M >> n;
	for (int i = 1; i <= n; i++)
	{
		cin >> w[i];
	}
	for (int i = 1; i <= n; i++)
	{
		cin >> p[i];
	}
	DP();
	Find(n, M);
    cout<<dp[n][M]<<" "<<endM<<endl;
	for(int i=1;i<n;i++){
        cout<<x[i]<<" ";
	}
    cout<<x[n];
	return 0;
}

2.不可回溯的滚动优化

滚动优化的方法用一维数组节省了二维数组的空间，dp[j]表示当前背包容量为j时的最大价值，需要注意的是每次遍历j需要倒序遍历到w[i]，倒序是为了防止之前的数据被覆盖过，减到w[i]是因为j<w[i]时什么也放不下，所以无需讨论。

递推关系式：dp[j]=max(dp[j],dp[j-w[i]]+p[i])

对于以上例题可用下面这种方法求最大价值：

#include<iostream>
using namespace std;

int M;
int dp[2000];
int n,w[2000],p[2000];

int main(){
    cin>>M>>n;
    for(int i=1;i<=n;i++){
        cin>>w[i];
    }
    for(int i=1;i<=n;i++){
        cin>>p[i];
    }
    for(int i=1;i<=n;i++){
        for(int j=M;j>=w[i];j--){           //这里要倒序遍历以避免覆盖之前的数据
            dp[j]=max(dp[j],dp[j-w[i]]+p[i]);
        }
    }
    cout<<dp[M];
    return 0;
}