【LeetCode动态规划#05】背包问题的理论分析（基于代码随想录的个人理解，多图）

背包问题

问题描述

背包问题是一系列问题的统称，具体包括：01背包、完全背包、多重背包、分组背包等（仅需掌握前两种，后面的为竞赛级题目）

下面来研究01背包

实际上即使是最经典的01背包，也不会直接出现在题目中，一般是融入到其他的题目背景中再考察

因为是学习原理，所以先跳过最原始的问题模板来学。

01背包的原始题意是：（标准的背包问题）

有n件物品和一个最多能背重量为 w 的背包。第 i 件物品的重量是 weight[i] ，得到的价值是 value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。

（01背包问题可以使用暴力解法，每一件物品其实只有两个状态，取或者不取，所以可以使用回溯法搜索出所有的情况，那么时间复杂度就是O(2^n)，这里的n表示物品数量。因为暴力搜索的时间复杂度是指数级别的，所以才需要通过dp来进行优化）

根据上面的描述可以举出以下例子

二维dp数组01背包

背包最大重量为4。

物品为：

	重量	价值
物品0	1	15
物品1	3	20
物品2	4	30

问背包能背的物品最大价值是多少？

五部曲分析一波

五步走

1、确定dp数组含义

该问题中的dp数组应该是二维的，所以先定义一个dp[i][j]

该数组的含义是什么？

含义：任取编号（下标）为[0, i]之间的物品放进容量为j的背包里

2、确定递推公式

确定递推公式之前，要明确dp[i][j]可以由哪几个方向推导出

当前背包的状态取决于放不放物品i，下面分别讨论

（1）不放物品i

dp[i - 1][j]

（2）放物品i

dp[i - 1][j - weight[i]] + value[i] （物品i的价值）

我来解释一下上面的式子是什么意思

先回顾一下dp[i][j]的含义：从下标为[0, i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。

那么可以有上述两个方向推出来dp[i][j]

情况1：不放物品i。此时我们已经认为物品i不会被放到背包中，那么根据dp[i][j]的定义，任取物品的范围应该变成[0, i-1]

也就是从下标为[0, i-1]的物品里任意取，放进容量为j的背包，价值总和最大是多少，即dp[i - 1][j]

再看情况2：放物品i。因为要放物品i，那就不需要再遍历到i了（相当于已经放入背包的东西下次就不遍历了）

根据dp[i][j]的定义，任取物品的范围也应该变成[0, i-1]

但是，因为情况2是要将物品i放入背包，此时背包的容量也要发生变化

根据dp[i][j]的定义，背包的容量应该要减去物品i的重量 weight[i] ，即dp[i - 1][j - weight[i]]

此时dp[i - 1][j - weight[i]]只是做好了准备放入物品i的工作，实际上物品i并没有放入，因此该式子的含义是：背包容量为j - weight[i]的时候不放物品i的最大价值

所以要再加上物品i本身的价值 value[i] ，才能求出背包放物品i得到的最大价值

即：dp[i - 1][j - weight[i]] + value[i]

根据dp[i][j]的定义，我们最后要求价值总和最大物品放入方式

因此递推公式应该是： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

从不放物品i和放物品i两个方向往dp[i][j]推，取最后结果最大的那种方式（即最优的方式）

3、确定dp数组初始化方式

可以把dp数组试着画出来，然后假设要求其中一个位置，思考可以从哪个方向将其推出，而这些方向最开始又是由哪些方向推得的，进而确定dp数组中需要初始化的部分

将本题的dp数组画出来如下：

假设有一个要求的元素dp[x][x]，根据前面对递推公式的讨论可知，该元素一定是由两个方向推过来求得的。

也就是情况1、情况2，那么对应到图中就是从上到下推过来的，是情况1（dp[i - 1][j]）

情况2（dp[i - 1][j - weight[i]]）在图中体现得不是十分确定，但是大致方向是从左上角往下推过来的

这两个方向的源头分别指向绿色区域和橙色区域

那么这两个区域就是要初始化的区域，怎么初始化呢？

先说橙色区域，从dp[i][j]的定义出发，如果背包容量j为0的话，即dp[i][0]，无论是选取哪些物品，背包价值总和一定为0。

所以橙色区域区域需要初始化为0

再说绿色区域，状态转移方程 dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]); 可以看出 i 是由 i-1 推导出来，那么 i 为 0 的时候就一定要初始化

dp[0][j]，即：i 为0，存放 编号0 的物品的时候，各个容量的背包所能存放的最大价值。

很明显当 j < weight[0]的时候，dp[0][j] 应该是 0，因为背包容量比编号0的物品重量还小。

当j >= weight[0]时，dp[0][j] 应该是 value[0] ，因为背包容量放足够放编号0物品。

两个区域的初始化情况对应到图中如下：

初始化代码：

for (int j = 0 ; j < weight[0]; j++) { //橙色区域
    dp[0][j] = 0;
}
// 正序遍历
for (int j = weight[0]; j <= bagweight; j++) {//绿色区域
    dp[0][j] = value[0];
}

以上两个区域实际上属于“含0下标区域”，其他的“非0下标区域”也需要初始化（没想清楚为什么有时要初始化完整个dp数组，有时又不用）

“非0下标区域”初始化为任何值都可以

还是拿前面的图来看

以dp[x][x]这个位置为例，其初始化成100、200都无所谓，因为这个位置的dp值是由其上面和左上两个方向上的情况推导出来的，只取决于这里个方向最开始的初始化值。

（例如dp[x][x]这里初始化为100，我从上面推导下来之后会用推导值将100覆盖）

4、确定遍历方式

该问题中dp数组有两个维度：物品、背包容量，先遍历哪个呢？

直接说结论，都行，但是先遍历物品更好理解

（具体看代码随想录解释）

两种过程的图如下：

（这里需要重申一下背包问题的条件：每个物品只能用一次，要求的是怎么装背包里的价值最大）

先遍历物品再遍历背包容量（固定物品编号，遍历背包容量）

​ 挑一个节点来说一下（图中的红框部分），此时的遍历顺序是先物后包，物品1(重3价20)在0~4种容量中放置的结果如图所示

​ 因为固定了物品1，此时背包容量为0、1、2的情况都是放不下物品1的（也放不下物品2），所以只能放物品0（此为最佳选择）

​ 当遍历到背包容量为3时，可以放下物品1了，那此处的最佳选择就是放一个物品1，所以此处的dp数组值变为20

​ 其余位置分析方法同理

先遍历背包容量再遍历物品（固定背包容量，遍历物品编号）

​ 有了前面的例子，这里就很好理解了，就是从上往下遍历，固定住当前背包的容量，遍历物品，看看能不能放入，能放的话最优选择应该放哪个

​ 还是拿红框部分来说，此时背包容量固定为3

​ 第一次遍历，物品0可以装下，此时最优选择就是放物品0，背包总价是15；

​ 第二次遍历，物品1可以装下，此时最优选择就是放物品1，背包总价是20；

​ 第三次遍历，物品2装不下，此时最优选择就是放物品1，背包总价还是20；

​ 其余位置分析方法同理

完整c++测试代码（卡哥）

void test_2_wei_bag_problem1() {
    vector<int> weight = {1, 3, 4};
    vector<int> value = {15, 20, 30};
    int bagweight = 4;//背包容量

    // 创建二维数组
    vector<vector<int>> dp(weight.size(), vector<int>(bagweight + 1, 0));

    // 初始化dp数组
    for (int j = weight[0]; j <= bagweight; j++) {
        dp[0][j] = value[0];
    }

    // weight数组的大小 就是物品个数
    for(int i = 1; i < weight.size(); i++) { // 遍历物品
        for(int j = 0; j <= bagweight; j++) { // 遍历背包容量
            if (j < weight[i]) dp[i][j] = dp[i - 1][j];//背包容量小于物品重量，此时为不放当前遍历物品的情况
            //背包容量大于物品重量，那就在放与不放之间选用最大的那种情况
            else dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

        }
    }

    cout << dp[weight.size() - 1][bagweight] << endl;
}

int main() {
    test_2_wei_bag_problem1();
}

一维数组下的背包问题

观察一下之前讨论的背包问题的递推公式 dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);

使用二维dp数组来解决背包问题时有两种情况，简单来说就是背包容量（或者物品编号）变了，可以选择放入物品或者不放入物品

先看不放的情况

不放的话我们都知道递推公式就是：dp[i][j] = dp[i - 1][j];

也就是说，当前dp[i][j]和上一次的dp[i][j]还是一样的（因为没有放入物品），所以这里的i和i-1就没有区别了，因此可以合并在一块写

那么完整的递推公式此时变成：dp[i][j] = max(dp[i][j], dp[i][j - weight[i]] + value[i]);

这种"重复利用上一层结果"的操作相当于将上一层"拷贝"至当前层

既然i可以拷贝，那j也应该可以，那不如直接使用一个一维数组，若上一层结果可以重复使用的话，就直接"拷贝"到当前层

明确了为什么可以压缩背包问题的状态，下面可以开始用五部曲去讨论背包问题中，一维数组的含义

五步走

1、确定dp数组的含义

这里因为压缩了状态，所以不用再区分物品和容量，进保留容量即可

dp[j]:容量为j的背包，所背的物品最大价值为dp[j]

2、确定递推公式

还是先考虑dp[j]可以由哪些状态推导得到

与二维时情况类似，这里依旧有放入物品和不放入物品，两种状态

先来看不放入物品

不放物品的话，dp[j]就还是取上一层自身的值，即dp[j ]

再来看放入物品

放入的话，除了把容量减掉，还要加上对应容量物品的价值，即dp[j - weight[i]] + value[i]

表示 容量为 "j - 物品i重量" 的背包 加上 "物品i的价值"。（也就是容量为j的背包，放入物品i了之后的价值即：dp[j]）
此时，dp[j]有dp[j]和dp[j - weight[i]] + value[i]两种选择，根据要求我们选最大的那个

综上所述，完整的递推公式为：

dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

和二维情况时很像

3、一维dp数组如何初始化

初始化时，一定要与dp数组的含义对应

dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]

那么dp[0]就应该是0，因为背包容量为0所背的物品的最大价值就是0，其他位置如何初始化？

看一眼上面的递推公式，我们总是去取所背的物品的最大值

因此，如果题目给的物品值均为正数，那dp[0]以外的位置应该初始化为0，这样才可以保证在递推过程中，判断累加所得的最大值不会被初始值覆盖

举个例子，当j移动到5处时，即dp[5]，如果此前所背物品价值累加为10，而当前dp[5]的初始值是100，就会把之前的值覆盖掉（这里例子不太恰当，以后会修改，仅供参考）

如果是有负数的情况怎么办？ 那么非0下标就要初始化为负无穷，保证初始值怎么都不会覆盖递推所得的值

4、确定遍历顺序

先摆结论：一维dp写法时，需要先遍历物品再遍历背包容量，并且需要倒序遍历

（1）为什么要倒序遍历？

还是先说结论：倒序遍历是为了保证物品i只被放入一次！。但如果一旦正序遍历了，那么物品0就会被重复加入多次！

举个例子，有物品0的重量为weight[0] = 1，价值value[0] = 15

若使用正序遍历会出现以下情况

dp[0] = 0；---初始化是0
dp[1] = dp[1 - weight[0]] + value[0] = 15;
dp[2] = dp[2 - weight[0]] + value[0] = 30;

解释一下后面两个式子

当j为1时，表示容量为1，此时能够放下一个物品0，根据递推公式dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);，我们应该让 dp[j] 等于 dp[j - weight[i]] + value[i] ，即需要放入物品，因此有了上述式子

当j为2时，容量为2，根据递推公式此时确实需要放入物品，因为当前层容量还够啊，这个逻辑没有问题（因为是照着递推公式来的）

但是，由于遍历顺序是正序遍历，在计算dp[2]时会把dp[1]的结果累加进来，这显然是错误的，因为每个物品只能放一次，不能因为某一层容量够就放两次

那这里你可能会想，那我选不放的情况（dp[j] = dp[j]）就好了啊

但是这样就不满足递推公式的要求了，根据递推公式，只要容量够，就要放东西，这样最后才能得到最大值

那不能该规则就只能该遍历顺序了呗，所以一定要使用倒序遍历

以防万一再来看看倒序遍历的情况（使用物品0不断尝试放入不同容量的背包）

倒序就是先算dp[2]

dp[2] = dp[2 - weight[0]] + value[0] = 15;
dp[1] = dp[1 - weight[0]] + value[0] = 15;
dp[0] = 0；---初始化是0

当j为2时，容量为2，根据递推公式此时需要放入物品，因此选择dp[j] = dp[j - weight[i]] + value[i] 的情况

把物品0放入

当j为1时，容量为1，根据递推公式此时还是可以放入物品，因此dp[j] = dp[j - weight[i]] + value[i]

但我们知道，物品0在dp[2]时已经被放入，所以dp[1]其实没东西可以放，正好此时通过计算，dp[1] = dp[0] + 15

正好相当于没放东西进来，但是按递推公式的规则也说得过去，所以没有问题

从本质上说，倒序遍历就是为了防止之前层结果对当前层结果的影响

这与二维dp写法中的思路正好相反，二维时需要利用之前的递推结果来推导出之后的结果（对于二维dp，dp[i][j]都是通过上一层即dp[i - 1][j]计算而来，本层的dp[i][j]并不会被覆盖）

（2）为什么要先物品再背包容量？

不可以的原因是，如果在一维dp的写法下先遍历背包容量的话那么不管如何，背包中永远只能加一个物品，就会漏掉一些最大值的情况

例如，使用固定的背包容量不断尝试放入不同重量的物品

假设当前容量是5，有物品0、1，价值分别为1、4

当遍历到物品0时，肯定要放入背包，此时总价为1；

当遍历到物品1时，肯定也要放入背包，此时总价为4；（因为是倒序遍历，无法累加前面加入背包的物品0）

显然这样是会漏掉真正最大价值，即5的情况

5、打印dp数组

为了再次以防万一，这里我把dp数组推导一次

从右往左倒序遍历，物品0遍历各个背包容量的情况就不说了

当用物品遍历背包容量4位置时，背包可以装物品0 和 物品1，过程如下：

当用物品遍历背包容量3位置时，背包可以装物品0 或 物品1，选择装物品1，过程如下：

其他位置同理

完整c++测试代码（卡哥）

void test_1_wei_bag_problem() {
    vector<int> weight = {1, 3, 4};
    vector<int> value = {15, 20, 30};
    int bagWeight = 4;//背包容量

    // 初始化dp数组
    vector<int> dp(bagWeight + 1, 0);
    for(int i = 0; i < weight.size(); i++) { // 遍历物品
        for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
            dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
        }
    }
    cout << dp[bagWeight] << endl;
}

int main() {
    test_1_wei_bag_problem();
}