代码随想录-刷题第四十三天

1049. 最后一块石头的重量 II

题目链接：1049. 最后一块石头的重量 II

思路：本题其实就是尽量让石头分成重量相同的两堆，相撞之后剩下的石头最小，这样就化解成0-1背包问题了。与416. 分割等和子集非常相似。

动态规划五步曲：

1. dp[j]：容量（其实就是重量）为j的背包，最多可以背最大重量为dp[j]。

   可以回忆一下0-1背包中，dp[j]的含义，容量为j的背包，最多可以装的价值为 dp[j]。

   相对于 0-1背包，本题中，石头的重量是 stones[i]，石头的价值也是 stones[i] ，可以 “最多可以装的价值为 dp[j]” == “最多可以背的重量为dp[j]”

2. 递推公式：dp[j] = max(dp[j], dp[j - stones[i]] + stones[i])

   0-1背包的递推公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i])

3. 初始化：0-1背包分割子集问题，dp数组的长度为物品总重量的一半。dp[0] = 0，因为重量都不会是负数，其他非0下标处也为0。

4. 遍历顺序：先顺序遍历物品，再倒序遍历背包容量（防止重复放入）。

5. 举例推导dp数组

   输入：[2,4,1,1]，此时target = (2 + 4 + 1 + 1)/2 = 4 ，dp数组状态图如下：

   

   最后dp[target]里是容量为target的背包所能背的最大重量。

   那么分成两堆石头，一堆石头的总重量是dp[target]，另一堆就是sum - dp[target]。

   在计算target的时候，target = sum / 2 因为是向下取整，所以sum - dp[target] 一定是大于等于dp[target]的。

class Solution {
    public int lastStoneWeightII(int[] stones) {
        // dp[j] 表示容量为j的背包，最多可以背最大重量为dp[j]。
        int sum = 0;
        for (int stone : stones) {
            sum += stone;
        }
        int target = sum / 2;
        // dp数组的长度为物品总重量的一半
        int[] dp = new int[target + 1];
        for (int i = 0; i < stones.length; i++) { // 遍历物品
            for (int j = target; j >= stones[i]; j--) { // 遍历背包
                dp[j] = Math.max(dp[j], dp[j - stones[i]] + stones[i]);
            }
        }
        return sum - dp[target] - dp[target];
    }
}

---

494. 目标和

题目链接：494. 目标和

思路：假设加法的总和为x，那么减法对应的总和就是sum - x。所以我们要求的是 x - (sum - x) = target，进而x = (target + sum) / 2。此时问题就转化为，装满容量为x的背包，有几种方法。这里的x，就是bagSize，也就是我们后面要求的背包容量。

再回归到0-1背包问题，为什么是0-1背包呢？

因为每个物品（题目中的1）只用一次！

这次和之前遇到的背包问题不一样了，之前都是求容量为j的背包，最多能装多少。

本题则是装满有几种方法。其实这就是一个组合问题了。

本题就变成了0-1背包求组合问题，动态规划五步曲：

1. dp[j]：填满j（包括j）这么大容积的背包，有dp[j]种方法。

2. 递推公式：dp[j] += dp[j - nums[i]]

   只要搞到nums[i]，凑成dp[j]就有dp[j - nums[i]] 种方法。

   例如：dp[j]，j 为5，

   • 已经有一个1（即nums[i] = 1）的话，有 dp[4]种方法 凑成 容量为5的背包
   • 已经有一个2（即nums[i] = 2）的话，有 dp[3]种方法 凑成 容量为5的背包
   • 已经有一个3（即nums[i] = 3）的话，有 dp[2]中方法 凑成 容量为5的背包
   • 已经有一个4（即nums[i] = 4）的话，有 dp[1]中方法 凑成 容量为5的背包
   • 已经有一个5（即nums[i] = 5）的话，有 dp[0]中方法 凑成 容量为5的背包

   那么凑成dp[5]有多少方法呢，也就是把所有的 dp[j - nums[i]] 累加起来。

   这个递推公式在之后背包解决排列组合问题的时候还会用到！

3. 初始化：dp[0] = 1

   因为dp[0]是在公式中一切递推结果的起源，如果dp[0]是0的话，递推结果将都是0。

4. 遍历顺序：nums放在外循环，bagSize 在内循环，且内循环倒序。

5. 举例推导dp数组

   输入：nums: [1, 1, 1, 1, 1], target: 3

   bagSize = (target + sum) / 2 = (3 + 5) / 2 = 4

   dp数组状态变化如下：

   

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        // dp[j] 表示填满容量为j的背包，共有dp[j]种方法
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        
        if ((target + sum) % 2 != 0) return 0; // 此时没有方案
        if (Math.abs(target) > sum) return 0;  // 此时没有方案
        // 背包的容量为nums里面需要相加的总值
        int bagSize = (target + sum) / 2;
        int[] dp = new int[bagSize + 1];
        dp[0] = 1;
        for (int i = 0; i < nums.length; i++) {
            for (int j = bagSize; j >= nums[i]; j--) {
                dp[j] += dp[j - nums[i]];
            }
        }
        
        return dp[bagSize];
    }
}

看到(target + sum) / 2 应该考虑计算的过程中向下取整有没有影响。

例如 sum 是5，target 是2的话，不能被2整除其实就是无解的；

同时如果 target 的绝对值已经大于 sum，sum 将无法满足

例如[1,1,1,1,1] target = 6，而 sum 最大只能达到5。

本题也可以用回溯法进行暴力搜索，但是执行时间会过长。如果仅仅是求个数的话，就可以用dp，但回溯算法：39. 组合总和要求的是把所有组合列出来，还是要使用回溯法的。

---

474. 一和零

题目链接：474. 一和零

思路：本题中strs 数组里的元素就是物品，每个物品都是一个！而 m 和 n 相当于是一个背包，两个维度的背包。

本题依然是0-1背包问题，但是背包有两个维度，就是存放0的个数和存放1的个数，而不同长度的字符串就是不同大小的待装物品。

动态规划五步曲：

1. dp[i][j]：最多由i个0和j个1的strs的最大子集的大小为dp[i][j]。

2. 递推公式：

   dp[i][j] = Math.max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1)

   dp[i][j]可以由前一个strs里的字符串推导出来，strs里的字符串有zeroNum个0，oneNum个1。在遍历的过程中，取dp[i][j]的最大值。

   0-1背包的递推公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

   对比一下就会发现，字符串的zeroNum和oneNum相当于物品的重量（weight[i]），字符串本身的个数相当于物品的价值（value[i]）。

   这就是一个典型的0-1背包！ 只不过物品的重量有了两个维度而已。

3. 初始化：dp[0][0] = 0

   因为物品价值不会是负数，初始为0，保证递推的时候dp[i][j]不会被初始值覆盖。

4. 遍历顺序：先顺序遍历物品，再倒序遍历背包容量。

   物品就是strs里的字符串，背包容量就是题目描述中的m和n。

5. 举例推导dp数组

   以输入：[“10”,“0001”,“111001”,“1”,“0”]，m = 3，n = 3为例

   最后dp数组的状态如下所示：

   

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        // dp[i][j] 代表最多由i个0和j个1的最大子集大小为dp[i][j]
        int[][] dp = new int[m + 1][n + 1];
        for (String str : strs) { // 遍历物品
            int zeroNum = 0, oneNum = 0;
            char[] chs = str.toCharArray();
            for (char ch : chs) {
                if (ch == '0') {
                    zeroNum++;
                } else {
                    oneNum++;
                }
            }
            
            // 遍历背包容量且从后往前遍历！
            for (int i = m; i >= zeroNum; i--) {
                for (int j = n; j >= oneNum; j--) {
                    dp[i][j] = Math.max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);
                }
            }
        }
        return dp[m][n];
    }
}

那个遍历背包容量的两层for循环先后顺序有没有什么讲究？

没讲究，都是物品重量的一个维度，先遍历哪个都行！

---

0-1背包总结

0-1背包有多种应用（不同维度上的应用）：

• 纯 0-1 背包是求给定背包容量，装满背包的最大价值是多少。
• 416. 分割等和子集是求给定背包容量，能不能装满这个背包。
• 1049. 最后一块石头的重量 II是求给定背包容量，尽可能装，最多能装多少。
• 494. 目标和是求给定背包容量，装满背包有多少种方法。
• 474. 一和零是求给定背包容量，装满背包最多有多少个物品。

---