代码随想录Day 37|完全背包理论，题目：518.零钱兑换Ⅱ、377.组合总和Ⅱ、70.爬楼梯进阶

LluckyYH

于 2024-09-08 13:28:03 发布

阅读量595

点赞数 9

文章标签： leetcode 算法人工智能数据结构动态规划

本文链接：https://blog.csdn.net/LuckyYH__/article/details/142025472

版权

提示：DDU，供自己复习使用。欢迎大家前来讨论~

文章目录

动态规划Part05
完全背包理论基础
初始数据
==01背包问题解法：==
结论
为什么倒序遍历
==完全背包解法：==
结论
为什么正序遍历

二、题目
题目一：518.零钱兑换II
解题思路：
动规五步曲

题目三：377. 组合总和 Ⅳ
解题思路：

题目四：70. 爬楼梯（进阶版）
问题描述
解题思路：
问题难点

总结

动态规划Part05

完全背包理论基础

有N件物品和一个最多能背重量为W的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品都有无限个（也就是可以放入背包多次），求解将哪些物品装入背包里物品价值总和最大。

完全背包和01背包问题唯一不同的地方就是，每种物品有无限件。

01背包和完全背包唯一不同就是体现在遍历顺序上，所以本文就不去做动规五部曲了，直接针对遍历顺序经行分析！

正序遍历（物品可以使用无限次），倒序遍历（物品每次只能使用一次）

01背包的核心代码：

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]);
    }
}

我们知道01背包内嵌的循环是从大到小遍历，为了保证每个物品仅被添加一次。

完全背包核心代码：

完全背包的物品是可以添加多次的，所以要从小到大去遍历，即：

// 先遍历物品，再遍历背包
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]);

    }
}

下面给出一个例子，便于理解两种背包的解法：

初始数据

物品重量 weight = {1, 2, 3, 4}
物品价值 value = {10, 21, 30, 43}
背包容量 bagWeight = 5

01背包问题解法：

动态规划数组初始化

我们首先初始化一个动态规划数组 dp，其大小为背包容量加1（因为容量从0开始），初始值都为0。

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]);
    }
}

详细步骤

我们逐步分析代码的执行过程：

初始 dp 数组

dp = [0, 0, 0, 0, 0, 0]

遍历物品1 (重量1, 价值10)

容量5: dp[5] = max(0, dp[4] + 10) = max(0, 0 + 10) = 10
容量4: dp[4] = max(0, dp[3] + 10) = max(0, 0 + 10) = 10
容量3: dp[3] = max(0, dp[2] + 10) = max(0, 0 + 10) = 10
容量2: dp[2] = max(0, dp[1] + 10) = max(0, 0 + 10) = 10
容量1: dp[1] = max(0, dp[0] + 10) = max(0, 0 + 10) = 10

更新后的 dp 数组：

dp = [0, 10, 10, 10, 10, 10]

遍历物品2 (重量2, 价值21)

容量5: dp[5] = max(10, dp[3] + 21) = max(10, 10 + 21) = 31
容量4: dp[4] = max(10, dp[2] + 21) = max(10, 10 + 21) = 31
容量3: dp[3] = max(10, dp[1] + 21) = max(10, 10 + 21) = 31

更新后的 dp 数组：

dp = [0, 10, 10, 31, 31, 31]

遍历物品3 (重量3, 价值30)

容量5: dp[5] = max(31, dp[2] + 30) = max(31, 10 + 30) = 41
容量4: dp[4] = max(31, dp[1] + 30) = max(31, 10 + 30) = 41
容量3: dp[3] = max(31, dp[0] + 30) = max(31, 0 + 30) = 31

更新后的 dp 数组：

dp = [0, 10, 31, 31, 41, 41]

遍历物品4 (重量4, 价值43)

容量5: dp[5] = max(41, dp[1] + 43) = max(41, 10 + 43) = 53
容量4: dp[4] = max(41, dp[0] + 43) = max(41, 0 + 43) = 43

更新后的 dp 数组：

dp = [0, 10, 31, 31, 41, 53]

结论

最终，dp[5] 的值是53，这意味着在背包容量为5的情况下，我们可以通过选择一些物品组合得到最大价值53。

为什么倒序遍历

倒序遍历的目的是确保在计算 dp[j] 时，dp[j - weight[i]] 还没有被当前物品 i 影响。这样，我们可以确保每次计算都是基于没有包含当前物品的最优解。

通过这个例子，你可以看到倒序遍历是如何确保每个物品只被计算一次，并且每次计算都是基于正确的子问题。

完全背包解法：

动态规划数组初始化

我们同样初始化一个动态规划数组 dp，其大小为背包容量加1（因为容量从0开始），初始值都为0。

cpp

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

代码逻辑

完全背包问题的代码逻辑是两层循环：

外层循环遍历每个物品。
内层循环从当前物品的重量开始，一直遍历到背包的最大容量。

cpp

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]);
    }
}

详细步骤

我们逐步分析代码的执行过程：

初始 dp 数组

dp = [0, 0, 0, 0, 0, 0]

遍历物品1 (重量1, 价值10)

容量1: dp[1] = max(0, dp[0] + 10) = max(0, 0 + 10) = 10
容量2: dp[2] = max(0, dp[1] + 10) = max(0, 10 + 10) = 20
容量3: dp[3] = max(0, dp[2] + 10) = max(0, 20 + 10) = 30
容量4: dp[4] = max(0, dp[3] + 10) = max(0, 30 + 10) = 40
容量5: dp[5] = max(0, dp[4] + 10) = max(0, 40 + 10) = 50

更新后的 dp 数组：

dp = [0, 10, 20, 30, 40, 50]

遍历物品2 (重量2, 价值21)

容量2: dp[2] = max(20, dp[0] + 21) = max(20, 0 + 21) = 21
容量3: dp[3] = max(30, dp[1] + 21) = max(30, 10 + 21) = 31
容量4: dp[4] = max(40, dp[2] + 21) = max(40, 21 + 21) = 42
容量5: dp[5] = max(50, dp[3] + 21) = max(50, 31 + 21) = 52

更新后的 dp 数组：

dp = [0, 10, 21, 31, 42, 52]

遍历物品3 (重量3, 价值30)

容量3: dp[3] = max(31, dp[0] + 30) = max(31, 0 + 30) = 31
容量4: dp[4] = max(42, dp[1] + 30) = max(42, 10 + 30) = 42
容量5: dp[5] = max(52, dp[2] + 30) = max(52, 21 + 30) = 52

更新后的 dp 数组：

dp = [0, 10, 21, 31, 42, 52]

遍历物品4 (重量4, 价值43)

容量4: dp[4] = max(42, dp[0] + 43) = max(42, 0 + 43) = 43
容量5: dp[5] = max(52, dp[1] + 43) = max(52, 10 + 43) = 53

更新后的 dp 数组：

dp = [0, 10, 21, 31, 43, 53]

结论

最终，dp[5] 的值是53，这意味着在背包容量为5的情况下，我们可以通过选择一些物品组合得到最大价值53。

为什么正序遍历

在完全背包问题中，正序遍历的原因是我们需要确保在计算 dp[j] 时，dp[j - weight[i]] 表示的是包含当前物品多次的最优解。由于物品可以被无限次选取，我们从当前物品的重量开始，逐步增加容量，每次都尝试放入更多的当前物品，直到不能再放入为止。

通过这个例子，你可以看到正序遍历是如何确保每个物品可以被多次选取，并且每次计算都是基于包含当前物品多次的最优解。

完整的C++代码：

// 先遍历物品，在遍历背包
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();
}

小结：

对于纯完全背包问题，其for循环的先后循环是可以颠倒的！

本质上是，无论你何种遍历顺序，都依赖于当前位置左侧和上侧的数据，只要两层都是正序遍历，那么左侧和上侧肯定都已经得到更新（有值），就能求当前位置的值。

二、题目

题目一：518.零钱兑换II

518. 零钱兑换 II

解题思路：

这是一道典型的背包问题，一看到钱币数量不限，就知道这是一个完全背包。

但本题和纯完全背包不一样，纯完全背包是凑成背包最大价值是多少，而本题是要求凑成总金额的物品组合个数！

注意题目描述中是凑成总金额的硬币组合数，为什么强调是组合数呢？

例如示例一：

5 = 2 + 2 + 1

5 = 2 + 1 + 2

这是一种组合，都是 2 2 1。

如果问的是排列数，那么上面就是两种排列了。

组合不强调元素之间的顺序，排列强调元素之间的顺序。（区别排列数）

动规五步曲

来分析如下：

确定dp数组以及下标的含义

dp[j]：凑成总金额j的货币组合数为dp[j]

确定递推公式

dp[j] 就是所有的dp[j - coins[i]]（考虑coins[i]的情况）相加。

所以递推公式：dp[j] += dp[j - coins[i]];

这个递推公式,求装满背包有几种方法，公式都是：dp[j] += dp[j - nums[i]];

dp数组如何初始化

在动态规划中，特别是在处理硬币找零问题或类似的组合问题时，dp[0] 的初始化为1具有特定的意义。这个初始化是问题定义的一部分，它基于一个重要的假设：能够凑成总金额为0的组合数为1。这个假设是合理的，因为“不使用任何硬币凑成金额0”本身就是一种有效的组合方式。

为什么 dp[0] 要初始化为1？

基础情况：在很多问题中，尤其是涉及到组合计数的问题，dp[0] 表示凑成总金额（或总价值、总重量等）为0的方案数。在这种情况下，只有一种方式可以达到这个目标，即不使用任何物品或硬币。因此，dp[0] = 1 表示存在一种方式可以凑成0的总金额。
递归公式的基石：在动态规划的递推过程中，dp[0] 作为基准值，确保了递归公式的正确性。例如，在硬币找零问题中，如果dp[j] 表示凑成金额j的方案数，那么dp[0] = 1 确保了递归公式 dp[j] = dp[j] + dp[j - coin] 在j为0时是有效的。
表示一种选择：dp[0] = 1 也可以理解为，对于任何金额j，总有一种选择是“不使用任何硬币”，这种选择是有效的，且是唯一的。
确定遍历顺序

本题中我们是外层for循环遍历物品（钱币），内层for遍历背包（金钱总额），还是外层for遍历背包（金钱总额），内层for循环遍历物品（钱币）呢？

完全背包的两个for循环的先后顺序都是可以的, 但本题就不行了！

因为纯完全背包求得装满背包的最大价值是多少，和凑成总和的元素有没有顺序没关系，即：有顺序也行，没有顺序也行！

而本题要求凑成总和的组合数，元素之间明确要求没有顺序。

所以纯完全背包是能凑成总和就行，不用管怎么凑的。

本题是求凑出来的方案个数，且每个方案个数是为组合数。

那么本题，两个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]];
    }
}

假设：coins[0] = 1，coins[1] = 5。

那么就是先把1加入计算，然后再把5加入计算，得到的方法数量只有{1, 5}这种情况。而不会出现{5, 1}的情况。

所以这种遍历顺序中dp[j]里计算的是组合数！

如果把两个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]];
    }
}

背包容量的每一个值，都是经过 1 和 5 的计算，包含了{1, 5} 和 {5, 1}两种情况。

此时dp[j]里算出来的就是排列数！

建议动手把这两种方案的dp数组数值变化打印出来，对比看一看！（实践出真知）

举例推导dp数组

输入: amount = 5, coins = [1, 2, 5] ，dp状态图如下：

518.零钱兑换II

最后红色框dp[amount]为最终结果。

以上分析完毕，C++代码如下：

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[amount];
    }
};

时间复杂度: O(mn)，其中 m 是amount，n 是 coins 的长度
空间复杂度: O(m)

小结：

本题的递推公式，和目标和类似，而难点在于遍历顺序！

在求装满背包有几种方案的时候，认清遍历顺序是非常关键的。

如果求组合数就是外层for循环遍历物品，内层for遍历背包。

如果求排列数就是外层for遍历背包，内层for循环遍历物品。

题目三：377. 组合总和 Ⅳ

377. 组合总和 Ⅳ：求排列数

解题思路：

本题题目描述说是求组合，但又说是可以元素相同顺序不同的组合算两个组合，其实就是求排列！

弄清什么是组合，什么是排列很重要。

组合不强调顺序，(1,5)和(5,1)是同一个组合。

排列强调顺序，(1,5)和(5,1)是两个不同的排列。

但其本质是本题求的是排列总和，而且仅仅是求排列总和的个数，并不是把所有的排列都列出来。

如果本题要把排列都列出来的话，只能使用回溯算法爆搜。

动规五部曲分析如下：

确定dp数组以及下标的含义

dp[i]: 凑成目标正整数为i的排列个数为dp[i]

确定递推公式

dp[i]（考虑nums[j]）可以由 dp[i - nums[j]]（不考虑nums[j]）推导出来。

因为只要得到nums[j]，排列个数dp[i - nums[j]]，就是dp[i]的一部分。

求装满背包有几种方法，递推公式一般都是dp[i] += dp[i - nums[j]];

本题也一样。

dp数组如何初始化

因为递推公式dp[i] += dp[i - nums[j]]的缘故，dp[0]要初始化为1，这样递归其他dp[i]的时候才会有数值基础。

至于dp[0] = 1 有没有意义呢？

其实没有意义，所以我也不去强行解释它的意义了，因为题目中也说了：给定目标值是正整数！所以dp[0] = 1是没有意义的，仅仅是为了推导递推公式。

至于非0下标的dp[i]应该初始为多少呢？

初始化为0，这样才不会影响dp[i]累加所有的dp[i - nums[j]]。

确定遍历顺序

个数可以不限使用，说明这是一个完全背包。

得到的集合是排列，说明需要考虑元素之间的顺序。

本题要求的是排列，那么这个for循环嵌套的顺序可以有说法了。

如果求组合数就是外层for循环遍历物品，内层for遍历背包。

如果求排列数就是外层for遍历背包，内层for循环遍历物品。

如果把遍历nums（物品）放在外循环，遍历target的作为内循环的话，举一个例子：计算dp[4]的时候，结果集只有 {1,3} 这样的集合，不会有{3,1}这样的集合，因为nums遍历放在外层，3只能出现在1后面！

所以本题遍历顺序最终遍历顺序：target（背包）放在外循环，将nums（物品）放在内循环，内循环从前到后遍历。

举例来推导dp数组

用示例中的例子推导一下：

377.组合总和Ⅳ

如果代码运行处的结果不是想要的结果，就把dp[i]都打出来，看看和我们推导的一不一样。

以上分析完毕，C++代码如下：

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

时间复杂度: O(target * n)，其中 n 为 nums 的长度
空间复杂度: O(target)

C++测试用例有两个数相加超过int的数据，所以需要在if里加上dp[i] < INT_MAX - dp[i - num]。

题目四：70. 爬楼梯（进阶版）

爬楼梯（第八期模拟笔试）

问题描述

你正在爬楼梯，总共有 n 阶台阶。
每次你可以爬1到 m 个台阶。
需要计算出爬到楼顶的不同方法数。

解题思路：

这是一个经典的动态规划问题——爬楼梯问题的一个变种，这个问题可以用完全背包问题的解法来解决。

定义状态：定义 dp[i] 为爬到第 i 阶台阶的方法数。
状态转移：对于每一阶台阶 i（从1到 n），你可以从之前的1到 m 阶台阶跳到这一阶。因此，dp[i] 可以从 dp[i-1], dp[i-2], …, dp[i-m] 转移而来。
初始化：dp[0] = 1，表示有1种方法爬到地面（即不爬），这是基础情况。
计算顺序：从小到大计算 dp[i] 的值，因为计算 dp[i] 需要依赖于之前台阶的方法数。
最终结果：dp[n] 就是爬到第 n 阶台阶的方法数。

问题难点

与传统的爬楼梯问题（通常每次只能爬1或2个台阶）不同，这个问题允许你每次爬1到 m 个台阶，增加了问题的复杂性。

动规五部曲分析如下：

确定dp数组以及下标的含义

dp[i]：爬到有i个台阶的楼顶，有dp[i]种方法。

确定递推公式

递推公式一般都是dp[i] += dp[i - nums[j]];

本题，dp[i]有几种来源，dp[i - 1]，dp[i - 2]，dp[i - 3] 等等，即：dp[i - j]

那么递推公式为：dp[i] += dp[i - j]

dp数组如何初始化

既然递归公式是 dp[i] += dp[i - j]，那么dp[0] 一定为1，dp[0]是递归中一切数值的基础所在，如果dp[0]是0的话，其他数值都是0了。

下标非0的dp[i]初始化为0，因为dp[i]是靠dp[i-j]累计上来的，dp[i]本身为0这样才不会影响结果

确定遍历顺序

这是背包里求排列问题，即：1、2 步和 2、1 步都是上三个台阶，但是这两种方法不一样！

所以需将target放在外循环，将nums放在内循环。

每一步可以走多次，这是完全背包，内循环需要从前向后遍历。

举例来推导dp数组

本题和377. 组合总和 Ⅳ几乎是一样的。

以上分析完毕，C++代码如下：

#include <iostream>
#include <vector>
using namespace std;
int main() {
    int n, m;
    while (cin >> n >> m) {
        vector<int> dp(n + 1, 0);
        dp[0] = 1;
        for (int i = 1; i <= n; i++) { // 遍历背包
            for (int j = 1; j <= m; j++) { // 遍历物品
                if (i - j >= 0) dp[i] += dp[i - j];
            }
        }
        cout << dp[n] << endl;
    }
}

时间复杂度: O(n * m)
空间复杂度: O(n)

代码中m表示最多可以爬m个台阶，代码中把m改成2就是力扣：70.爬楼梯的解题思路。

总结

完全背包理论

无限使用：每种物品可以无限使用，没有数量限制。
状态转移：当前物品的价值是之前所有价值的累加，即 dp[j] += dp[j - weight[i]]，表示加上当前物品后的新价值。
循环顺序：通常从小到大遍历物品和背包容量，确保每次计算时使用的是未包含当前物品的旧价值。

LluckyYH

关注

9
点赞
踩
19

收藏

觉得还不错? 一键收藏
0
评论
代码随想录Day 37|完全背包理论，题目：518.零钱兑换Ⅱ、377.组合总和Ⅱ、70.爬楼梯进阶

完全背包理论无限使用：每种物品可以无限使用，没有数量限制。状态转移：当前物品的价值是之前所有价值的累加，即，表示加上当前物品后的新价值。循环顺序：通常从小到大遍历物品和背包容量，确保每次计算时使用的是未包含当前物品的旧价值。
复制链接

扫一扫