代码随想录算法训练营-day43-1049. 最后一块石头的重量 II、494.目标和、474.一和零

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

1. 学习文章链接：
2. 思路：基于分割等和子集。详情见注释。
3. 代码：

class Solution {
    public int lastStoneWeightII(int[] stones) {
        // 与分割等和子集很相似
        int sum = 0;
        for (int i = 0; i < stones.length; i++) {
            sum += stones[i];
        }
        int target = sum / 2;
        int[] dp = new int[target + 1];
     494   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.目标和

1. 学习文章链接：
2. 思路：组合问题的递推公式与01背包的基本公式有了不同，详情见注释。
3. 代码：

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        // 加法的总和为x，那么减法对应的总和就是sum - x
        // 所以我们要求的是 x - (sum - x) = target
        // x = (target + sum) / 2
        // 此时问题就转化为，装满容量为x背包，有几种方法。
        // 这里的x，就是bagSize，也就是我们后面要求的背包容量。
        int sum = 0;
        for (int i = 0; i < nums.length; i++) sum += nums[i];
        // 如果目标值的绝对值大于数组和，那一定没有方案。
        if (Math.abs(target) > sum) return 0;
        int x = (target + sum) / 2;
        // target 和 sum 必须同为奇数或偶数才行，否则会出现向下取整的情况。
        if ((target + sum) % 2 == 1) return 0;
        // dp[j] 表示：填满j（包括j）这么大容积的包，有dp[j]种方法
        int[] dp = new int[x + 1];
        // 从递归公式可以看出，在初始化的时候dp[0] 一定要初始化为1，
        // 因为dp[0]是在公式中一切递推结果的起源，如果dp[0]是0的话，递归结果将都是0。
        dp[0] = 1;
        for (int i = 0; i < nums.length; i++) {
            for (int j = x; j >= nums[i]; j--) {
                // 组合问题的递推公式，大多如此。
                dp[j] += dp[j - nums[i]];
            }
        }
        return dp[x];
    }
}

474.一和零

1. 学习文章链接：
2. 思路：两个维度出发的01背包，重要的是理解好dp数组的含义，和递推公式的由来。
3. 代码：

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        // 最多有i个0和j个1的strs的最大子集的大小为dp[i][j]。
        int[][] dp = new int [m + 1][n + 1];
        for (String s : strs) {
            int zeroNum = 0;
            int oneNum = 0;
            for (int i = 0; i < s.length(); i++) {
                if (s.charAt(i) == '0') {
                    zeroNum++;
                } else {
                    oneNum++;
                }
            }
            // dp[i][j] 可以由前一个strs里的字符串推导出来，strs里的字符串有zeroNum个0，oneNum个1。
            // 
            // dp[i][j] 就可以是 dp[i - zeroNum][j - oneNum] + 1。
            // 
            // 然后我们在遍历的过程中，取dp[i][j]的最大值。
            // 
            // 所以递推公式：dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);
            // 
            // 此时大家可以回想一下01背包的递推公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
            // 
            // 对比一下就会发现，字符串的zeroNum和oneNum相当于物品的重量（weight[i]），字符串本身的个数相当于物品的价值（value[i]）。
            // 
            // 这就是一个典型的01背包！ 只不过物品的重量有了两个维度而已。
            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];
    }
}