背包DP：0-1背包问题探究

概要

动态规划是一种通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。 由于动态规划并不是某种具体的算法，而是一种解决特定问题的方法，因此它会出现在各式各样的数据结构中，与之相关的题目种类也更为繁杂

而背包问题，是动态规划系列问题中较经典的问题，其涵盖了许多类型，如0-1背包，完全背包，多重背包，混合背包，分组背包等等，本文从0-1背包这一简单问题出发。

1.1 0-1背包描述

由经典问题出发 读者可以先自行做一下这道题 或许您会开创新的思路嘿嘿
0-1背包问题
0-1背包问题是一个经典的动态规划问题，其基本形式是：有一个容量为 $\mathrm{V}$ 的背包和 $\mathrm{N}$ 件物品，每件物品有其对应的体积 $v_i$ 和价值 $w_i$，要求选择若干物品装入背包，使得装入背包中物品的总价值最大。其中每个物品只能选择装入一次 。即每个物品只存在被取 0 次或 1 次。

1.2 简析问题

求解属性

求 $\mathrm{MAX}$ ，即状态返回的是最大价值情况

状态表示

$f(i,j)$ 表示前 $\mathrm{i}$ 个物品，体积不超过 $\mathrm{j}$ 的情况下可以获得的最大价值。

状态集合划分

对于第 $\mathrm{i}$ 个物品，我们有两种选择，要么选，要么不选。对这个物品1进行判断，即将 $\mathrm{N}$ 个物品的大问题转换成了一个小问题。

1. 不放入背包，此时背包的最大价值为$f(i-1,j)$ 。
2. 放入背包，放入背包，此时背包的最大价值为 $f(i-1,j-v_i)+w_i$

理解

对于第一种的公式很容易理解：去掉一个物品的选择然后计算最大价值
而对于第二种公式的理解似乎有些技巧，这里有一个理解方式为：曲线救国
第一种选择计算很简单，那么我们就在第一种选择的基础上做文章，我们绕一下

1. 先去掉第i个物品 注意：前提既要保证数量 也要保证第$\mathrm{i}$物品的体积
2. 在去掉的基础上求解 $\mathrm{MAX}$，即 $f(i-1,j-v_i)$
3. 再加回第 $\mathrm{i}$ 个物品的价值
   以上思想适用于其他背包问题 在不同取法下存在差异

状态计算

既然存在两种情况，那么就要在每次循环迭代下就要有选择取舍，由于求解属性为$\mathrm{MAX}$ ，那么我们尽可能在每次选择时都取最大的那种情况。
因此，状态转移方程为
f ( i , j ) = max ⁡ { f ( i − 1 , j ) , f ( i − 1 , j − v i ) + w i } f(i,j)=\max\{f(i-1,j),f(i-1,j-v_i)+w_i\} f(i,j)=max{f(i−1,j),f(i−1,j−vi​)+wi​}

2.1 二维代码实现（朴素版

//二维数组的朴素版本 
#include<iostream>
using namespace std;
const int N = 10010;
int w[N], v[N], f[N][N];
int n, m;
int main(){
	cin >> n >> m;
	for (int i = 1; i <= n; i++)
		cin >> w[i] >> v[i];
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= m; j++)
		{
			if (j < w[i])
				f[i][j] = f[i - 1][j]; 
			else
				f[i][j] = max(f[i - 1][j], f[i - 1][j - v[i]] + w[i]);
		}
	cout << f[n][m] << endl;
	return 0;
}

代码解释

初次看到这个代码或许有这些疑问

• $if(j<w[i])$判断条件：
  当我们的下一个物品的体积超过了我们背包的极限时，我们无法将其带上
  所以面对此物品是我们的决策应该于上一个物品是一样的
• $else${ }在体积允许的情况下：
  当我们能带上某件物品时我们需要决策一下这件物品值不值得我们拿
  因此，我们需要比较一下拿上它的价值和不拿的价值

为何说此版本为朴素版本呢，当我们高高兴兴去交一发的时候，MLE了！看一下空间复杂度O(nm)，在较高的数据量下 ，确实有可能会MLE，那么如何改进呢？

真的理解了吗？

相信有些同学看似会了，但是这个$f(i,j)$数组究竟是怎么操作的你真的明白吗？
同时，想要优化空间，必须先弄懂$f(i,j)$数组的功能。

我们从$\mathrm{i}=1$开始，$\mathrm{i}$ 代表了什么呢？$\mathrm{i}$ 代表了行，第 $\mathrm{i}$ 行意味着当我们的背包里有 $\mathrm{i}$ 个东西时我们的决策，$\mathrm{j}$ 是一项约束，是从1到我们背包的最大容量，一开始$\mathrm{i}=1$ ；$\mathrm{j}=1$； 就是代表了当背包里只能有一个物品，同时容量最大为1时，我们背包里所能有的最大价值，接着j渐渐变大，也就是在受到物品限制1个的情况下容量渐渐变大，我们所能获得的最大价值，由于我们先前初始化初态均为0，我们遵循二循环的操作，不断通过f[0]行进行更新。不断得到新的决策，保证了我们容量不断变大时记录下真正的最大价值。

而后，i ++，当背包物品约束变为两个时，容量依然从1开始慢慢变大，那么对于第二行来说，我们的基准态就是上一行记录下的价值，保证了我们的决策的正确性。

以此类推，我们不难看出，每次我们的基准态都是上一次循环的内容，而更早的内容就成了占位置的僵尸数据，因此我们想，那我们用一个一维数组存储基准态，下一次我们直接将其更新，不就不会有僵尸数据了吗？

优化点

对于二维的数组而言，我们发现开了$N^{\ast }N$的空间，且存下每次迭代的数据结果，但是观察状态转移方程即我们分析的过程和输出的结果，我们只需要最后一次的结果，且不难发现第$\mathrm{i}$次的计算只跟第$\mathrm{i}-1$有关。

2.2 一维数组优化(顺序

//滚动数组的顺序更新 （存在重复选择 错误
#include<iostream>
using namespace std;
const int N = 10010;
int w[N], v[N],f[N];
int n, m;
int main()
{
	cin >> n >> m;
	for (int i = 1; i <= n; i++)
		cin >> w[i] >> v[i];
	for (int i = 1; i <= n; i++)
		for (int j = 1; j <= m; j++)
		{
			if (j < w[i])
				f[j] = f[j];
			else
				f[j] = max(f[j], f[j - w[i]] + v[i]);
		}
	cout << f[m] << endl;
}

AC了吗？

迫不及待将其转换成一维时，但仍红惨了。这是为何？
我们发现，在更新新基准态的时候，我们是从前向后更新的，从而导致了有可能$f(j-w[i])$会被更新，但是我们后面的数据需要原来的基准数据，导致错误。 这样解释可能过于空洞 请继续往下看看。

为什么一维情况下枚举背包容量需要逆序？

在二维情况下，状态$f(i,j)$是由上一轮$\mathrm{i}-1$的状态得来的，$f(i,j)$与$f(i-1,j)$是独立的。而优化到一维后，如果我们还是正序，则有$f(较小体积）$更新到$f(较大体积)$，则有可能本应该用第 $\mathrm{i}-1$ 轮的状态却用的是第 $\mathrm{i}$ 轮的状态。

举个栗子

例如，一维状态第$\mathrm{i}$轮对体积为 3 价值为 5 的物品进行决策，则$f(7)$由$f(4)$更新而来，这里的$f(4)$正确应该是$f(i-1,4)$，但从小到大枚举$\mathrm{j}$ 这里的$f(4)$在第i轮计算却变成了$f(i,4)$。当逆序枚举背包容量$\mathrm{j}$ 时，我们求$f(7)$同样由$f(4)$更新，但由于是逆序，这里的$f(4)$还没有在第i轮计算，所以此时实际计算的$f(4)$仍然是f[i - 1][4]。

既然已经知道逆序更新才行 快再写一版代码吧

2.3 一维数组（逆序更新

#include <iostream>
#include<algorithm>
using namespace std;
 
const int N = 10010;
int w[N], v[N];
int f[N];
int n ,m;
 
int main()
{
	cin >> n >> m;
	for(int i = 1; i <= n; i ++)
		cin >> w[i] >> v[i];
	for(int i = 1; i <= n; i ++)
		for(int j = m; j >= 1; j --)
		{
			if(j < w[i])
				f[j] = f[j];
			else
				f[j] = max(f[j], f[j - w[i]] + v[i]);
		}	
	cout << f[m] << endl;
}

这时你突然发现 AC啦 这就是逆序的神奇魅力嘛哈哈
至于滚动数组 其实这种一维数组也就是滚动数组，但从更直观的角度，我们可有开一个$f[2][m]$的数组，这样就不怕新数据覆盖旧值的情况出现了。
有兴趣的读者可以浏览这篇博客滚动数组 （简单说明）

2.4 一维滚动数组（逆序更新 最终优化版

//一维滚动数组加逆序更新(优化版 正确
#include<iostream>
#include<algorithm>
using namespace std;
const int N = 10010;
int n, m; int v[N], w[N], f[N];
int main() {
    cin >> n >> m;
    for (int i = 1; i <= n; i++) cin >> v[i] >> w[i];
    for (int i = 1; i <= n; i++)
        for (int j = m; j >= v[i]; j--)//逆序更新 避免重复选择
            dp[j] = max(f[j], f[j - v[i]] + w[i]);
    cout << f[m] << endl;
    return 0;
}

3.0小结

对于0-1背包问题这一背包DP的开胃菜 从二维朴素版到一维顺序版再到最后的一维逆序更新版本 经历了MLE 到红灿灿再到最后的AC ，这一过程给我们带来了不一样的体验，也收获了许多

至此 本人对于0-1背包的理解到此结束 感谢您的阅读 希望对您有所帮助
如有任何错误 欢迎您的批评指教