代码随想录算法训练营第四十三天 | 1049. 最后一块石头的重量 II、494. 目标和、474.一和零

代码随想录算法训练营第四十三天 | 1049. 最后一块石头的重量 II、494. 目标和、474.一和零

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

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

动态规划算法

思路：

1. 确定 dp 数组以及下标的含义： dp[j] 代表容量为 j 的背包所装石头的最大重量；
2. 确定递推公式： 参考 01 背包的一维解法，dp[j] = Math.max(dp[j - 1], dp[j - weight[i]] + value[i])，可知本题的递推公式为 dp[j] = Math.max(dp[j - 1], dp[j - stones[i]] + stones[i])；
3. dp数组如何初始化 从dp[j]的定义来看，首先 dp[0] 一定是 0。本题中石头的重量一定为正数，所以非 0 下标的元素初始化为 0 就可以了。
4. 确定遍历顺序 参考 01 背包一维解法的遍历顺序，必须先遍历物品再遍历背包。
5. 举例推导dp数组 如图所示
   

class Solution {
    public int lastStoneWeightII(int[] stones) {
        int sum = 0;
        for (int weight : stones) {
            sum += weight;
        }
        int target = sum / 2;
        // 1.确定 dp 数组及下标含义
        int[] dp = new int[target + 1];
        // 3.初始化 dp 数组
        dp[0] = 0;
        // 4.确定遍历顺序
        for (int i = 0; i < stones.length; i++) {
            // 滚动数组的内层循环需要倒序
            for (int j = target; j >= stones[i]; j--) {
                // 2.确定递推公式
                dp[j] = Math.max(dp[j], dp[j - stones[i]] + stones[i]);
            }
        }
        
        // 5.打印 dp 数组

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

494. 目标和

题目链接：494. 目标和

动态规划算法

思路：假设 left 为待添加 ‘+’ 号的元素集合，right 为待添加 ‘-’ 号的元素集合，则left - right = target；又因为left + right = sum，则由两式可得 left = (target + sum) / 2；

1. 确定 dp 数组以及下标的含义： dp[j] 填满 j（包括 j）这么大容积的包，有 dp[j] 种方法
2. 确定递推公式： 只要得到 nums[i]，凑成 dp[j] 就有 dp[j - nums[i]] 种方法；

所有组合类问题都有类似公式—— dp[j] += dp[j - nums[i]]

3. dp数组如何初始化 从递推公式可以看出，在初始化的时候 dp[0] 一定要初始化为 1，因为 dp[0] 是在公式中一切递推结果的起源，如果 dp[0] 是 0 的话，递推结果将都是 0。
4. 确定遍历顺序 参考 01 背包一维解法的遍历顺序，必须先遍历物品再遍历背包，且内循环倒序。
5. 举例推导dp数组 如图所示
   

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int sum = 0;
        for (int i = 0; i < nums.length; i++) sum += nums[i];
	    // 如果 target 过大 sum 将无法满足
        // if ( target > 0 && sum < target) return 0;
        if ( target < 0 && sum < -target) return 0;
        if ((target + sum) % 2 != 0) return 0; // 找不到目标和方法

        // size 为正数（添加 '+' 的元素）集合
        int size = (target + sum) / 2;
        if(size < 0) size = -size;

        // 1.确定 dp 数组及下标含义
        int[] dp = new int[size + 1];
        // 3.初始化 dp 数组
        dp[0] = 1;
        // 4.确定遍历顺序
        for (int i = 0; i < nums.length; i++) {
            for (int j = size; j >= nums[i]; j--) {
                // 2.确定递推公式
                dp[j] += dp[j - nums[i]];
            }
        }

        // 5.打印 dp 数组

        return dp[size];
    }
}

474.一和零

题目链接：474.一和零

动态规划算法

思路：本题首先明确是 01 背包不是完全背包，因为物品的数量都是一个，只不过这个背包有两个维度，一个是 m，一个是 n，而不同长度的字符串就是不同大小的待装物品。

1. 确定 dp 数组以及下标的含义： 最多有 i 个 0 和 j 个 1 的 strs 的最大子集的大小为 dp[i][j]。
2. 确定递推公式：
   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]）。
3. dp数组如何初始化 因为物品价值不会是负数，初始为0，保证递推的时候 dp[i][j] 不会被初始值覆盖。
4. 确定遍历顺序 参考 01 背包一维解法的遍历顺序，必须先遍历物品再遍历背包，且内循环倒序。物品就是 strs 里的字符串，背包容量就是题目描述中的 m 和 n。
5. 举例推导dp数组 如图所示

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        // dp[i][j] 表示 i 个 0 和 j 个 1 时的最大子集
        int[][] dp = new int[m + 1][n + 1];
        int oneNum, zeroNum;
        for (String str : strs) {
            oneNum = 0;
            zeroNum = 0;
            for (char ch : str.toCharArray()) {
                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];
    }
}