第九章动态规划 part05 1049. 最后一块石头的重量II 494. 目标和 474. 一和零-CSDN博客

本文链接：https://blog.csdn.net/qq_45498567/article/details/133078068

第四十三天| 第九章动态规划 part05 1049. 最后一块石头的重量II 494. 目标和 474. 一和零

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

题目链接：https://leetcode.cn/problems/last-stone-weight-ii/
题目介绍：
- 有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。
  
  每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：
  - 如果 x == y，那么两块石头都会被完全粉碎；
  - 如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。
  最后，最多只会剩下一块 石头。返回此石头 最小的可能重量 。如果没有石头剩下，就返回 0。
  
  示例 1：
```
输入：stones = [2,7,4,1,8,1]
输出：1
解释：
组合 2 和 4，得到 2，所以数组转化为 [2,7,1,8,1]，
组合 7 和 8，得到 1，所以数组转化为 [2,1,1,1]，
组合 2 和 1，得到 1，所以数组转化为 [1,1,1]，
组合 1 和 1，得到 0，所以数组转化为 [1]，这就是最优值。
```
思路：
- 怎么样得到的就是最小值呢？
- 将数组分成两份，即两个背包。取每个背包中装的最大值，两个相撞得到的就是最小值
- 所以就将本题中要求的“返回此石头最小的可能重量”转换为求一个容量为sum/2的背包中，能装的最大重量。
代码：

class Solution {
    public int lastStoneWeightII(int[] stones) {
        int sum = 0;
        for (int stone : stones) {
            sum += stone;
        }
        int target = sum/2;
        // (1)明确dp[j]含义：表示的是容量为j的背包中能放入的石头的最大重量之和
        int[] dp = new int[target + 1];
        // (3)初始化，跳过，全部初始化为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]);
            }
        }
        // 为什么是用另一个背包的重量，减去dp[target]呢？
        // 是因为target = sum / 2，相当于向下取整，即这个背包中能装的重量一定小于或等于sum的一半，即背包中的重量更少
        return (sum - dp[target]) - dp[target];
    }
}

注意：
- 为什么是用另一个背包的重量，减去dp[target]呢？
- 是因为target = sum / 2，相当于向下取整，即这个背包中能装的重量一定小于或等于sum的一半，即背包中的重量更少

二、494. 目标和

题目链接：https://leetcode.cn/problems/target-sum/
题目介绍：
- 给你一个非负整数数组 nums 和一个整数 target 。
  
  向数组中的每个整数前添加 '+' 或 '-' ，然后串联起所有整数，可以构造一个 表达式 ：
  - 例如，nums = [2, 1] ，可以在 2 之前添加 '+' ，在 1 之前添加 '-' ，然后串联起来得到表达式 "+2-1" 。
  返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。
  
  示例 1：
```
输入：nums = [1,1,1,1,1], target = 3
输出：5
解释：一共有 5 种方法让最终目标和为 3 。
-1 + 1 + 1 + 1 + 1 = 3
+1 - 1 + 1 + 1 + 1 = 3
+1 + 1 - 1 + 1 + 1 = 3
+1 + 1 + 1 - 1 + 1 = 3
+1 + 1 + 1 + 1 - 1 = 3
```

思路：

和前两到题的思路是一样的，将整个数组分为两个部分，一部分是正数，一部分是负数

背包的最大容量计算公式如下：

left表示正数集合
right表示负数集合
left + right = sum;
left - right = target; => right = left - target;
left + (left - target) = sum;
即：
	left = (sum + target) / 2;
	很明显，如果不能整除说明无法得到target，直接return 0;

DP五部曲：

（1）确定dp[j]含义：

dp[j]表示的是：装满背包容量为j的方法

（2）确定递推公式：

不放nums[i]：

如果不放dp[j]，那么就是dp[j]种方法能装满容量为j的背包，因为对于二维数组而言，这个dp[j]就是从上一层拷贝来的

放nums[i]：

如果放nums[i]，那么装满容量为j的背包的方法就有dp[j-nums[i]] * 1种，为什么是乘以1，因为放nums[i]这算1种方法。

所以递推公式：
- ```
dp[j] += dp[j-nums[i]];
```

（3）dp数组初始化：
- ```
dp[0] = 1;
```
- 为什么要把dp[0]初始化为1，可以从下图中理解：
  - 如果dp[0] = 0，那么整个数组就全是0了
（4）确定遍历顺序
- 正序遍历物品，倒序遍历背包

代码：

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int sum = 0;
        for (int num : nums) {
            sum += num;
        }
        if (sum < Math.abs(target)) return 0;
        if ((sum + target) % 2 != 0) return 0;
        int bagSize = (sum + target) / 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];
    }
}

总结：

分割等和子集、最后一块石头的重量II、目标和三道题都是01背包的应用，他们解决问题的思路可以从三个角度应用01背包的思路：
- （1）分割等和子集：将给定数组分为两个集合，背包的最大容量是数组总和的一半，判断该数组能否装满这个背包，能装满返回true，否则返回false；
  - 如果背包重量之和无法整除2，说明该数组不可能被分割为等和子集
- （2）最后一块石头的重量II：将给定数组分为两个集合，背包的最大容量是数组总和的一半，尽可能去装满该背包，那么两个背包相减剩下的石头重量就是最小的
  - 背包重量之和除以2向下取整，装满该背包之后，该背包的重量小于等于物品总重的一半，那么剩下的物品之和就大于这个背包的重量，用剩下的减去背包的最大重量就是最后一块石头的最小重量
- （3）目标和：将给定数组分为两个集合（一个正数，一个负数），背包的最大容量是数组总和的一半，返回的是装满该背包的方法有多少种

三、474. 一和零

题目链接：https://leetcode.cn/problems/ones-and-zeroes/

题目介绍：

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。

请你找出并返回 strs 的最大子集的长度，该子集中最多有 m 个 0 和 n 个 1 。

如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的子集。

示例 1：

输入：strs = ["10", "0001", "111001", "1", "0"], m = 5, n = 3
输出：4
解释：最多有 5 个 0 和 3 个 1 的最大子集是 {"10","0001","1","0"} ，因此答案是 4 。
其他满足题意但较小的子集包括 {"0001","1"} 和 {"10","1","0"} 。{"111001"} 不满足题意，因为它含 4 个 1 ，大于 n 的值 3 。

思路：
- 本题中strs 数组里的元素就是物品，每个物品都是一个！
  
  而m 和 n相当于是一个背包，两个维度的背包。
- 所以本题还是一个01背包的问题，只不过背包是二维的
- DP五部曲：
  - （1）确定dp及下标含义
    - ```
    背包要装的的m个0和n个1，所以定义一个二维dp数组
    dp[i][j]：表示的是装满i个0和j个1，最大子集的个数是dp[i][j]
```
- （2）确定递推公式：
  - ```
  max括号中的前者是不放该str，后者是放该str
  dp[i][j] = Math.max(dp[i][j], dp[i-zeroNum][j-oneNum] + 1);
```
  - （3）初始化dp数组：
    - 都初始化为0即可
  - （4）确定遍历顺序：
    - 先遍历物品，再遍历背包
代码：

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int[][] dp = new int[m+1][n+1];
        for(String str : strs) {
            int zeroNum = 0;
            int oneNum = 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];
    }
}