Day43｜动态规划part05： 1049. 最后一块石头的重量 II、494. 目标和、474. 一和零

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

本题物品的重量为stones[i]，物品的价值也为stones[i]。

对应着01背包里的物品重量weight[i]和 物品价值value[i]。

1. 确定dp数组以及下标的含义

dp[j]表示容量（这里说容量更形象，其实就是重量）为j的背包，最多可以背最大重量为dp[j]。

2. 确定递推公式

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

本题则是：dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);（与分割子集那题相同）

3. dp数组如何初始化

既然 dp[j]中的j表示容量，那么最大容量（重量）（也就是target）是多少呢，就是所有石头的重量和。

定为target15001即可， 也可以将数组相加再/2

4. 确定遍历顺序

在动态规划：关于01背包问题，你该了解这些！（滚动数组） (opens new window)中就已经说明：如果使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历！

5. 举例推导dp数组
6. 从0-1背包转化成实际问题

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

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

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

那么相撞之后剩下的最小石头重量就是 (sum - dp[target]) - dp[target]。

最终代码：

class Solution {
    public int lastStoneWeightII(int[] stones) {
        //思想：让重量相似的石头相撞这样得到的石头更小
        int sum = 0;
        for(int stone : stones){
            sum += stone;
        }
        int target = sum / 2;//像下取整的，target一定小于等于sum - target
        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. 目标和

这题的重点在于怎么把正负符号问题转化为定和->进而转化为0-1背包问题

本题要如何使表达式结果为target，

既然为target，那么就一定有 left组合 - right组合（添加负号的） = target。

left + right = sum，而sum是固定的。right = sum - left

公式来了， left - (sum - left) = target 推导出 left = (target + sum)/2 。

target是固定的，sum是固定的，left就可以求出来。

此时问题就是在集合nums中找出和为left的组合。（相当于0-1背包问题）

有两种解法，一个回溯，跟组合总和那题一样，第二种解法就是动态规划。

回溯

先空着，不剪枝会超时。

动态规划

x = (target + sum) / 2

此时问题就转化为，装满容量为x的背包，有几种方法。

dp五部曲

1. 确定dp数组下标及其含义

dp[j] 表示：填满j（包括j）这么大容积的包，有dp[j]种方法

2. 确定递推公式

只要搞到nums[i]，凑成dp[j]就有dp[j - nums[i]] 种方法。也就是说dp[j - nums[i]]渴望找到nums[i]，这样就符合要求了。因此递推公式是：

所以求组合类问题的公式，都是类似这种：

dp[j] += dp[j - nums[i]]

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

3. 初始化dp数组

只要初始化dp[0]即可，填满0的包，有1种方法，所以dp[0] = 1。

4. 确定遍历顺序

跟之前的一维0-1背包一样，先遍历物品再遍历背包，背包从后往前遍历。

5. 举例推导dp数组

[外链图片转存中…(img-PMOiMxzQ-1713323607584)]

最终代码：

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int sum = Arrays.stream(nums).sum();
        //如果target的绝对值大于sum，那么是没有方案的
        if (Math.abs(target) > sum) return 0;
        //如果(target+sum)除以2的余数不为0，也是没有方案的
        if ((target + sum) % 2 == 1) return 0;
        

        int left = (sum + target) / 2;

        int dp[] = new int[left + 1];
        dp[0] = 1;
        for(int i = 0; i < nums.length;i++){
            for(int j = left; j >= nums[i]; j--){
                dp[j] += dp[j - nums[i]];
            }
        }
        return dp[left];
    }
}

这里注意两个特殊情况， 一个是如果target的绝对值大于sum，那么是没有方案的，另一个是如果(target+sum)除以2的余数不为0，也是没有方案的。

474. 一和零

理解成多重背包的同学主要是把m和n混淆为物品了，感觉这是不同数量的物品，所以以为是多重背包。

但本题其实是01背包问题！

只不过这个背包有两个维度，一个是m 一个是n，而不同长度的字符串就是不同大小的待装物品。

dp五部曲

1. 确定dp数组（dp table）以及下标的含义

dp[i][j]：最多有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。

此时大家可以回想一下01背包的递推公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);

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

3. dp数组初始化

初始为0即可。

4. 遍历顺序

外层for循环遍历物品，内层for循环遍历背包容量且从后向前遍历！

for (string str : strs) { // 遍历物品
    int oneNum = 0, zeroNum = 0;
    for (char c : str) {
        if (c == '0') zeroNum++;
        else oneNum++;
    }
    for (int i = m; i >= zeroNum; i--) { // 遍历背包容量且从后向前遍历！
        for (int j = n; j >= oneNum; j--) {
            dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);
        }
    }
}

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