完全背包 推导过程 记忆化搜索、动态规划、时间优化、空间优化

题目介绍

有N种物品和一个容量为V的背包，每种物品都有无限件可用。第i种物品的费用是c[i]，价值是w[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。

1. 暴力递归

和01背包一样，只不过是多了一个循环，因为01背包对一个物品最多只要求取一次，而完全背包可以取N次

int dp[60][60];
int maxPrix(vector<int>& W, vector<int>& V, int C, int i)
{
	if (i == W.size()) return 0;
	int rs = 0;
	for (int n = 0; n * W[i] <= C; n++)
	{
		int nextC = C - n * W[i];
		int sumV = n * V[i];
		rs = max(rs, maxPrix(W, V, nextC, i + 1) + sumV);
	}
	return rs;
}

2. 记忆化搜索

缓存每个已经计算的状态

int dp[60][60];
int maxPrix(vector<int>& W, vector<int>& V, int C, int i)
{
	if (dp[i][C] >= 0) return dp[i][C];
	if (i == W.size()) return 0;
	int rs = 0;
	for (int n = 0; n * W[i] <= C; n++)
	{
		int nextC = C - n * W[i];
		int sumV = n * V[i];
		/*if (dp[i][nextC] >= 0) rs = max(rs, dp[i][nextC]);*/ // 这里不能做记忆化，因为下面的状态有多个
		/*rs = max(rs, max(maxPrix(W, V, nextC, i + 1) + sumV, maxPrix(W, V, C, i + 1)));*/
		// 上面一行的代码等效下面这行代码
		rs = max(rs, maxPrix(W, V, nextC, i + 1) + sumV);
	}
	dp[i][C] = rs;
	return rs;
}

3. 动态规划

根据递归函数改成动态规划，基本没啥区别，直接写，题目都不用看了

// 2. 改动态规划
int binBackpack1(vector<int>& W, vector<int>& V, int C)
{
	int n = W.size();
	vector<vector<int>> maxpix(n + 1, vector<int>(C + 1, 0)); // maxpix[i][j]表示物品为i背包剩余容量为j时的最大价值
	for (int i = 1; i <= n; i++) // 物品
	{
		for (int j = 1; j <= C; j++) // 背包容量
		{
			for (int n = 0; n * W[i - 1] <= j; n++)
			{
				int nextC = j - n * W[i - 1];
				int sumV = n * V[i - 1];
				// maxpix[i][j] = max(maxpix[i][j], max(maxpix[i - 1][nextC] + sumV, maxpix[i - 1][j]));
				maxpix[i][j] = max(maxpix[i][j], maxpix[i - 1][nextC] + sumV); // 当n==0时会计算maxpix[i - 1][j]

			}
		}
	}
	return maxpix[n][C];
}

4. 时间优化

这里需要注意，很多人才开始学的时候在这里卡了很久，我们先来试着看下时间优化后的代码，见他理解一遍，没看懂也没关系，下面我们通过画图的方式来说明一下他是怎么来的。

int binBackpack2(vector<int>& W, vector<int>& V, int C)
{
	int n = W.size();
	vector<vector<int>> maxpix(n + 1, vector<int>(C + 1, 0)); // maxpix[i][j]表示物品为i背包剩余容量为j时的最大价值
	for (int i = 1; i <= n; i++) // 物品
	{
		for (int j = 1; j <= C; j++) // 背包容量
		{
			if (W[i - 1] > j) maxpix[i][j] = maxpix[i - 1][j];
			else maxpix[i][j] = max(maxpix[i][j - W[i - 1]] + V[i - 1], maxpix[i - 1][j]);
		}
	}
	return maxpix[n][C];
}

首先尝试在第三不改成动态的规划的时候用手在纸上推导一遍，在推的过程中你会发现这样一个方程：
maxpix[i][j] = max(maxpix[i][j-W[i-1]]+V[i-1], maxpix[i-1][j])
解释：当前状态由上一个容量为j的物品和当前物品容量为j-W[i-1] + V[i]的物品在两者之间取最大值转移过来。

这个过程一定要在纸上推导一遍，不然很难理解

5. 空间优化

空间优化和01背包一样，只不过这里遍历的顺序和01背包相反
Q：但是为什么要按这样的顺序遍历呢？
A：因为当前状态计算的结果正好是下一个状态参考的依据，如果从后往前遍历的话由于是1维数组，当前状态需要的其它状态都还没有更新，故然会影响计算结果。
注： 如果不理解的可以取看下之前写得01背包问题（戳这里）

int binBackpack(vector<int>& W, vector<int>& V, int C)
{
	int n = W.size();
	vector<int> maxpix(C + 1, 0);
	for (int i = 1; i <= n; i++) // 物品
	{
		for (int j = 1; j <= C; j++) // 背包容量
		{
			//if (W[i - 1] > j) maxpix[j] = maxpix[j];
			//else maxpix[j] = max(maxpix[j - W[i - 1]] + V[i - 1], maxpix[j]);

			// 等效下面的代码
			if(W[i-1] <= j) maxpix[j] = max(maxpix[j - W[i - 1]] + V[i - 1], maxpix[j]);
		}
	}
	return maxpix[C];
}