day44 【动态回归】● 完全背包 ● 518. 零钱兑换 II ● 377. 组合总和 Ⅳ

完全背包

• 代码随想录 | 讲解链接

• 思路
  有N件物品，1个最多能装重量为W的背包。第i件物品的重量是weight[i]，其价值是value[i]。
  每件物品都有无限个（可以放入背包多次），求解将那些物品放入背包里，背包中物品价值总和最大吗 ·

  完全背包和01背包唯一不同的地方是，物品的个数。 完全背包每个物品有无数件，而01背包每个物品只有1件。

• 以纯完全背包问题讲解理论和原理:
  背包的最大重量为4

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

  每个物品都有无限多个。

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

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

• 完全背包问题：两个for循环的先后顺序不影响计算，因此先遍历背包再遍历物品也可以。代码如下：

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

• 纯完全背包代码：

  //先遍历物品，再遍历背包
  private static void testCompletePack(){
      int[] weight = {1, 3, 4};
      int[] value = {15, 20, 30};
      int bagWeight = 4;
      int[] dp = new int[bagWeight + 1];
      for (int i = 0; i < weight.length; i++){ // 遍历物品
          for (int j = weight[i]; j <= bagWeight; j++){ // 遍历背包容量
              dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);
          }
      }
      for (int maxValue : dp){
          System.out.println(maxValue + "   ");
      }
  }
  
  //先遍历背包，再遍历物品
  private static void testCompletePackAnotherWay(){
      int[] weight = {1, 3, 4};
      int[] value = {15, 20, 30};
      int bagWeight = 4;
      int[] dp = new int[bagWeight + 1];
      for (int i = 1; i <= bagWeight; i++){ // 遍历背包容量
          for (int j = 0; j < weight.length; j++){ // 遍历物品
              if (i - weight[j] >= 0){
                  dp[i] = Math.max(dp[i], dp[i - weight[j]] + value[j]);
              }
          }
      }
      for (int maxValue : dp){
          System.out.println(maxValue + "   ");
      }
  }
  

518. 零钱兑换Ⅱ

• 518. 零钱兑换Ⅱ | 题目链接

• 代码随想录 | 讲解链接

• 题目描述：
  给你一个整数数组 coins 表示不同面额的硬币，另给一个整数 amount 表示总金额。

  请你计算并返回可以凑成总金额的硬币组合数。如果任何硬币组合都无法凑出总金额，返回 0 。

  假设每一种面额的硬币有无限个。

  题目数据保证结果符合 32 位带符号整数。

    示例 1：
    输入：amount = 5, coins = [1, 2, 5]
    输出：4
    解释：有四种方式可以凑成总金额：
    5=5
    5=2+2+1
    5=2+1+1+1
    5=1+1+1+1+1
    
    示例 2：
    输入：amount = 3, coins = [2]
    输出：0
    解释：只用面额 2 的硬币不能凑成总金额 3 。
    
    示例 3：
    输入：amount = 10, coins = [10] 
    输出：1
  

• 动规五部曲

  1. dp[j]数组的含义：总金额为j的时候，有dp[j]种方法能凑出j

  2. 递归公式：
     dp[j] += dp[j- coins[i]]

  3. dp数组初始化
     dp[0] = 1

  4. 遍历顺序
     外层for遍历硬币，正序
     内层for遍历总额，正序
     这样遍历出来的是组合数，只有{1,5}不会有{5，1}

     如果外层遍历总额，
     内层遍历硬币，
     则遍历的是排列数，{1，5}和{5，1}算两种了。重复了。

• 代码：

  class Solution {
      public int change(int amount, int[] coins) {
          int[] dp = new int[amount + 1];
          dp[0] = 1;
          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];
      }
  }
  

377. 组合总和Ⅳ

• 377. 组合总和Ⅳ | 题目链接

• 代码随想录 | 讲解链接

• 题目描述：
  给你一个由 不同 整数组成的数组 nums ，和一个目标整数 target 。请你从 nums 中找出并返回总和为 target 的元素组合的个数。

  题目数据保证答案符合 32 位整数范围。

    示例 1：
    输入：nums = [1,2,3], target = 4
    输出：7
    解释：
    所有可能的组合为：
    (1, 1, 1, 1)
    (1, 1, 2)
    (1, 2, 1)
    (1, 3)
    (2, 1, 1)
    (2, 2)
    (3, 1)
    请注意，顺序不同的序列被视作不同的组合。
    
    示例 2：
    输入：nums = [9], target = 3
    输出：0
  

• 动规五部曲

  1. dp[j] 的含义：凑成j有dp[j]种方法。
  2. 递归公式：
     dp[j] += dp[j - nums[i]]
  3. 数组初始化
     dp[0] = 1;
  4. 遍历顺序
     根据示例，得到的是排列，所以要
     先遍历背包，在遍历物品。

  class Solution {
      public int combinationSum4(int[] nums, int target) {
          int[] dp = new int[target + 1];
          dp[0] = 1;
          for(int i = 0; i <= target; i++) {
              for(int j = 0; j < nums.length; j++) {
                  if(i >= nums[j]) { //如果此时背包的容量i 大于添加进来的物品的重量nums[j]，那就更新组合总数
                      dp[i] += dp[i - nums[j]];
                  }
              }
          }
          return dp[target];
      }
  }