LeetCode刷题笔记【34】：动态规划专题-6（完全背包、零钱兑换II、组合总合IV）

前置知识

这是背包问题的第三节, 关于背包问题的前两节中, 我们主要涉及的是"01背包问题", 即"一个物品可且尽可被选中一次";
而今天的"完全背包问题"中, 就涉及到"每个物品有无限个/每个物品都可以被选中若干次"的情况.

接下来会先用"经典完全背包问题"来介绍完全背包和01背包的区别, 以及需要注意的问题;
然后再用两个例题来说明: 从经典完全背包问题, 到完全背包问题的实际应用, 有什么细节的区别.

参考文章：
LeetCode刷题笔记【29】：动态规划专题-1（斐波那契数、爬楼梯、使用最小花费爬楼梯）
LeetCode刷题笔记【30】：动态规划专题-2（不同路径、不同路径 II）
LeetCode刷题笔记【31】：动态规划专题-3（整数拆分、不同的二叉搜索树）
LeetCode刷题笔记【32】：动态规划专题-4（二维背包问题、一维背包问题、分割等和子集）
LeetCode刷题笔记【33】：动态规划专题-5（最后一块石头的重量 II、目标和、一和零）

经典完全背包问题(纯完全背包问题)

题目描述

LeetCode链接：没有LeetCode原题, 用本地IDE进行说明讲解

解题思路

如何实现"物品可以被多次添加"?

我们回顾之前一维01背包问题的解题关键代码:

    for (int i = 0; i < weight.size(); ++i) {//外层循环用于遍历物品i
        for (int j = bagSize; j >= weight[i]; --j) {//内层循环用于遍历背包容量j
            dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
        }
    }

之前讲到一个重点: 一维01背包的内层循环必须从大到小遍历, 从而保证每个物品仅被添加一次.

而完全背包的不同就在于此: 只要内层循环从小到大遍历, 就可以表现完全背包问题中物品可以被多次添加的特点. 代码如下:

	for(int i = 0; i < weight.size(); i++) { // 遍历物品
	    for(int j = weight[i]; j <= bagSize; j++) { // 遍历背包容量
	        dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
	    }
	}

遍历物品和遍历背包容量(内外层遍历)能否调换?

对于01背包问题:
使用二维dp数组时, 两个for循环可以颠倒;
使用一维dp数组时, 两个for循环不可颠倒, 只能先遍历物品, 再遍历背包容量.

对于经典完全背包问题:
使用一维dp数组时, 两个for循环的顺序可以颠倒
两种不同遍历方式如下图所示:

遍历物品在外层循环，遍历背包容量在内层循环，状态如图：

遍历背包容量在外层循环，遍历物品在内层循环，状态如图：

代码

// 先遍历物品，在遍历背包
void test_CompletePack() {
    vector<int> weight = {1, 3, 4};
    vector<int> value = {15, 20, 30};
    int bagWeight = 4;
    vector<int> dp(bagWeight + 1, 0);
    for(int i = 0; i < weight.size(); i++) { // 遍历物品
        for(int j = weight[i]; j <= bagWeight; j++) { // 遍历背包容量
            dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
        }
    }
    cout << dp[bagWeight] << endl;
}
int main() {
    test_CompletePack();
}

// 先遍历背包，再遍历物品
void test_CompletePack() {
    vector<int> weight = {1, 3, 4};
    vector<int> value = {15, 20, 30};
    int bagWeight = 4;

    vector<int> dp(bagWeight + 1, 0);

    for(int j = 0; j <= bagWeight; j++) { // 遍历背包容量
        for(int i = 0; i < weight.size(); i++) { // 遍历物品
            if (j - weight[i] >= 0) dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
        }
    }
    cout << dp[bagWeight] << endl;
}
int main() {
    test_CompletePack();
}

PS: 这里说的完全背包问题, 以及关于循环是否可以调换的讨论, 都是针对"经典"完全背包问题而言的.
具体解题过程中会有各种变化, 需要注意, 比如今天接下来这两题.

518. 零钱兑换 II

题目描述

LeetCode链接：https://leetcode.cn/problems/coin-change-ii/description/

解题思路

初始化&递推公式

参考之前讲过的01背包问题<494. 目标和>
关于递推公式dp[j] += dp[j-coins[i]];, <494. 目标和>中给出了推导.
相应的, dp数组的dp[0]要初始化为1, 不然无法计算, 可以理解为"背包容量为0, 手里硬币也为0的时候, 有1种方法"

内层for循环顺序

从01背包问题, 发展到完全背包问题, 在写法而言只更改了内层for循环的遍历顺序, 从后到前改为由前到后.
重点在于要理解这种修改的意义.

内外层for循环的顺序(先遍历物品还是先遍历背包容量)

注意题目的描述, 问的是"组合数", 而不是"排列数", 组合不强调内部元素的排列顺序, 排列强调顺序;

如A={1, 2, 3}, B={3, 2, 1}, A B是同一个组合, 但是不同的排列.

上面提到的经典完全背包问题, 只需要求最后的最大收益value, 不涉及排列组合这些问题, 所以内外层for循环不影响结果, 但是这里就不一样了.

我们以题目中的例子: amount=5, coins=[1,2,5] 为例, 来看一下这两种不同的内外for循环顺序的区别:

① 外层for循环遍历物品（钱币），内层for遍历背包（金钱总额）

for (int i = 0; i < coins.size(); i++) { // 遍历物品
    for (int j = coins[i]; j <= amount; j++) { // 遍历背包容量
        dp[j] += dp[j - coins[i]];
    }
}

在过程中, 就是按照1, 2, 5 的顺序, 将这三枚钱币依次加入计算, 得到的结果也会是:
1, 1, 1, 1, 1;
1, 1, 1, 2;
1, 2, 2;
5;
这样, 按照1, 2, 5加入计算的顺序排列遍历的, 所以dp数组的最后结果是"组合数"

① 外层for循环遍历背包（金钱总额），内层for遍历物品（钱币）

for (int j = 0; j <= amount; j++) { // 遍历背包容量
    for (int i = 0; i < coins.size(); i++) { // 遍历物品
        if (j - coins[i] >= 0) dp[j] += dp[j - coins[i]];
    }
}

此时在计算背包中的值时, 考虑到的就是之前所有"排列"的数量, dp数组的结果, 自然也是"排列数"

这二者对比的差别很微妙, 可以自己算一下dp数组来看结果差异. 并且就结果而言, 就是
“求组合, 先遍历物品i; 求排列, 先遍历背包容量j”, 直接记忆也没问题.

代码

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        vector<int> dp(amount+1, 0);
        dp[0] = 1;
        for(int i=0; i<coins.size(); ++i){
            for(int j=coins[i]; j<=amount; ++j){
                dp[j] += dp[j-coins[i]];
            }
        }
        return dp.back();
    }
};

ps: 简短的代码, 背后居然有那么多乱七八糟的推导和背景知识, 真要命啊.

377. 组合总和 Ⅳ

题目描述

LeetCode链接：https://leetcode.cn/problems/combination-sum-iv/description/

解题思路

还是完全背包问题, 相比于上一题, 这一题求的是"排列", 而非"组合".
那么根据上一题的相关分析, 需要注意的点如下所示:
① dp[0] = 1;
② 递推公式: dp[j] += dp[j-nums[i]];
③ 外层遍历背包容量j, 内层遍历物品i(这样求的才是排列, 而不是组合);
④ 对于j的遍历, 要从小到大(这是完全背包和01背包的区别)

代码

class Solution {
public:
    int combinationSum4(vector<int>& nums, int target) {
        vector<int> dp(target+1, 0);
        dp[0] = 1;
        for(int j=0; j<=target; ++j){
            for(int i=0; i<nums.size(); ++i){
                if(j-nums[i]>=0 && dp[j] < INT_MAX-dp[j-nums[i]]){
                    dp[j] += dp[j-nums[i]];
                }
            }
        }
        return dp.back();
    }
};

总结

前两篇文章聚焦01背包, 今天聚焦完全背包, 需要注意以下几点:

① 01背包和完全背包的区别:
1.1 问题性质上: 物品能否重复选择放入
1.2 解题手法上: 对于背包容量j的遍历顺序, 是从大到小(01背包)还是从小到大(完全背包)

② 完全背包求的是组合还是排列
2.1 问题性质上: 元素顺序是否有意义
2.2 解题手法上:
如果求组合数就是外层for循环遍历物品，内层for遍历背包。
如果求排列数就是外层for遍历背包，内层for循环遍历物品。

整不明白的时候就画二维dp数组思考.

本文参考：
完全背包
518. 零钱兑换 II
377. 组合总和 Ⅳ