代码随想录打卡—day44—【DP】— 8.28 完全背包基础

1 完全背包基础

完全背包和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]);

    }
}

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

2 518. 零钱兑换 II + 322. 零钱兑换

518. 零钱兑换 II

根据上面学的理论，一次AC代码：

class Solution {
public:
    int dp[5005];   // 能正好装满i的背包的方式数目
    /*
    dp[j] += dp[j - coins[i]];
    dp[0] = 1;
    i++ j++
    模拟——
    */

    int change(int amount, vector<int>& coins) 
    {
        dp[0] = 1;

        for(int i = 0; i < coins.size(); i++)
            for(int j = 0; j <= amount; j++)
                if(j >= coins[i])dp[j] += dp[j - coins[i]];

        return dp[amount];
    }
};

• 讨论1：

首先dp[0]一定要为1，dp[0] = 1是 递归公式的基础。如果dp[0] = 0 的话，后面所有推导出来的值都是0了。dp[0]=1还说明了一种情况：如果正好选了coins[i]后，也就是j-coins[i] == 0的情况表示这个硬币刚好能选，此时dp[0]为1表示只选coins[i]存在这样的一种选法。

• 讨论2：两个for谁外谁内嵌的讨论（组合or排列）

在动态规划：关于完全背包，你该了解这些！ (opens new window)中讲解了完全背包的两个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数组数值变化打印出来，对比看一看！（实践出真知）

---

我在pad上模拟了一下，就能发现由于先背包后物体这样的循环方式会已经考虑了一次nums[i = 0...nums.size()-1]之后又反复考虑合法的nums[i = 0...nums.size()-1] 就会出现譬如除了[1,1,2]又算一次[1,2,1]这样的情况。所以如果以后又不明白可以看下图，或者再模拟一次，自然就发现这个现象了。

---

322. 零钱兑换

类似的一题：

class Solution {
public:
    long long dp[10005];   // 能正好装满i的背包的最少硬币个数
    /*
        dp[j] = min(dp[j],dp[j - coins[i]] + 1)
                    不装i  装i
        dp[0] = 0;
        其他非0下标初始化为INT_MAX
        i++ j++
        模拟——
        0 1 2 3 4 5 6 7 8 9 10 11 
        0 1 1 2 2 3 3 4 4 5 5 6 
        0 1 1 2 2 1 2 2 3 3 2 3 
    */

    int coinChange(vector<int>& coins, int amount) 
    {
        dp[0] = 0;
        for(int i = 1; i <= amount; i++)dp[i] = INT_MAX;

        for(int i = 0; i < coins.size(); i++)
        {
            for(int j = 0; j <= amount; j++)
                if(j >= coins[i])dp[j] = min(dp[j],dp[j - coins[i]] + 1);

            // for(int j = 0; j <= amount; j++)cout << dp[j] << ' ';
            // cout << endl;
        }

        if(dp[amount] == INT_MAX)return -1;
        else return dp[amount];
    }
};

3 377. 组合总和 Ⅳ

377. 组合总和 Ⅳ

大家在公众号里学习回溯算法专题的时候，一定做过这两道题目回溯算法：39.组合总和 (opens new window)和回溯算法：40.组合总和II (opens new window)会感觉这两题和本题很像！

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

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

即求给定背包容量，装满背包有多少种方式 + 组合问题。AC代码：

class Solution {
public:
    long long dp[1010];  //容积为i的背包装满时候 不同装载方式的排列数
    /*
    和零钱兑换很像
    dp[j] += dp[j - nums[i]]

    dp[0] = 1

    先背包容量j++ 后物体i++

    模拟：

    */

    int combinationSum4(vector<int>& nums, int target) {
        dp[0] = 1;

        for(int j = 0; j <= target; j++)
        {
            for(int i = 0; i < nums.size();i++)
            {
               // if(j >= nums[i] && dp[j])  // 一直过不了的写法 应该是两个数相加爆int但是我开了long long 还这个错而不是答案错误 见鬼了
                if(j >= nums[i] && dp[j] + dp[j - nums[i]] <= INT_MAX )  
                    dp[j] = (long long)(dp[j] + dp[j - nums[i]]);
            }
        }
        return dp[target];
    }
};

有个坑：C++测试用例有两个数相加超过int的数据，所以需要在if里加上dp[i] < INT_MAX - dp[i - num]。但我开了long long 那个地方还是一样的报错，见鬼了