算法打卡day38|动态规划篇06| 完全背包理论基础|Leetcode 518.零钱兑换II、377. 组合总和 Ⅳ

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背包内嵌的循环是从大到小遍历 ，为了保证每个物品仅被添加一次。而完全背包的物品是可以添加多次的 ，所以要从小到大去遍历，即：

java 复制代码

// 先遍历物品，再遍历背包
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状态图如下：

在01背包中二维dp数组的两个for遍历的先后循序是可以颠倒了，一维dp数组的两个for循环先后循序一定是先遍历物品，再遍历背包容量。在完全背包中，对于一维dp数组来说，其实两个for循环嵌套顺序是无所谓的！ 因为dp[j] 是根据下标j之前所对应的dp[j]计算出来的。只要保证下标j之前的dp[j]都是经过计算的就可以。

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

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

如上两个图，在完全背包中两个for循环的先后循序，都不影响计算dp[j]所需要的值（这个值就是下标j之前所对应的dp[j]）。先遍历背包在遍历物品，代码如下：

java 复制代码

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

算法题

Leetcode 518.零钱兑换II

题目链接:518.零钱兑换II

大佬视频讲解：零钱兑换II视频讲解

个人思路

因为题中说钱币数量不限，所以这是一个完全背包问题

解法

动态规划

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

例如示例一：

5 = 2 + 2 + 1

5 = 2 + 1 + 2

这是一种组合，都是 2 2 1。如果问的是排列数，那么上面就是两种排列了

组合不强调元素之间的顺序，排列强调元素之间的顺序。

动规五部曲：

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

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

2.确定递推公式

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

所以递推公式**：dp[j] += dp[j - coins[i]];（组合问题常用）**

这个递推公式和昨天做的494. 目标和一样

3.dp数组如何初始化

首先dp[0]一定要为1，dp[0] = 1是递归公式的基础 。如果dp[0] = 0 的话，后面所有推导出来的值都是0了。下标非0的dp[j]初始化为0，这样累计加dp[j - coins[i]]的时候才不会影响真正的dp[j]

4.确定遍历顺序

完全背包的两个for循环的先后顺序是无关紧要的，但本题就不行了！ 因为纯完全背包求得装满背包的最大价值是多少 ，和凑成总和的元素有没有顺序没关系 ，而本题要求凑成总和的组合数，元素之间明确要求没有顺序即****每个方案个数是为组合数。

先看外层for循环遍历物品（钱币），内层for遍历背包（金钱总额）的情况。代码如下：

java 复制代码

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交换顺序，代码如下：

java 复制代码

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]里算出来的就是排列数！

5.举例推导dp数组

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

java 复制代码

class Solution {
    public int change(int amount, int[] coins) {
        int[] dp = new int[amount + 1];
        dp[0] = 1;//初始化dp数组

        for (int i = 0; i < coins.length; i++) {//遍历钱币
            for (int j = coins[i]; j <= amount; j++) {//遍历总和
                dp[j] += dp[j - coins[i]];
            }
        }
        return dp[amount];
    }
}

时间复杂度:O( n^2**)**；（嵌套for循环）

空间复杂度:O( n**);**（存储一个长度为n+1的dp数组）

二维数组版本

java 复制代码

class Solution {
    public int change(int amount, int[] coins) {
        int[][] dp = new int[coins.length][amount+1];

        // 初始化边界值
        for(int i = 0; i < coins.length; i++){
            // 第一列的初始值为1
            dp[i][0] = 1;
        }
        for(int j = coins[0]; j <= amount; j++){
            // 初始化第一行
            dp[0][j] += dp[0][j-coins[0]];
        }
        

        for(int i = 1; i < coins.length; i++){
            for(int j = 1; j <= amount; j++){

                if(j < coins[i]) dp[i][j] = dp[i-1][j];
                else dp[i][j] = dp[i][j-coins[i]] + dp[i-1][j];

            }
        }

        return dp[coins.length-1][amount];
    }
}

时间复杂度:O( n^2**)**；（嵌套for循环）

空间复杂度:O( n^2**);**（dp二维数组）

Leetcode 377. 组合总和 Ⅳ

题目链接:377. 组合总和 Ⅳ

大佬视频讲解：组合总和 Ⅳ视频讲解

个人思路

这道题与上道题有些相像也是完全背包问题，不过这道题是求排列，所以遍历顺序与上题有所不同，只用求排列个数，可以用动规。

解法

动态规划

动规五部曲：

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

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

2.确定递推公式

dp[i]（考虑nums[j]）可以由 dp[i - nums[j]] 推导出来。因为只要得到nums[j]，排列个数dp[i - nums[j]]，就是dp[i]的一部分。

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

3.dp数组如何初始化

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

4.确定遍历顺序

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

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

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

5.举例来推导dp数组

我们再来用示例中的例子推导一下：

java 复制代码

class Solution {
    public int combinationSum4(int[] nums, int target) {
        int[] dp = new int[target + 1];
        dp[0] = 1;//dp数组初始化

        for (int i = 0; i <= target; i++) {//遍历背包（target）
            for (int j = 0; j < nums.length; j++) {//遍历物品(nums)
                if (i >= nums[j]) {
                    dp[i] += dp[i - nums[j]];
                }
            }
        }
        return dp[target];
    }
}

时间复杂度:O( n^2**)**；（嵌套for循环）

空间复杂度:O( n**);**（存储一个长度为n+1的dp数组）

以上是个人的思考反思与总结，若只想根据系列题刷，参考卡哥的网址代码随想录算法官网