代码随想录Day31动态规划：1049最后一块石头的重量II_494目标和_474一和零

1049最后一块石头的重量II

题目：有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：如果 x == y，那么两块石头都会被完全粉碎；

如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。

最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0。

链接：https://leetcode.cn/problems/last-stone-weight-ii/

本题尽量让石头分成重量相同的两堆（尽可能相同），相撞之后剩下的石头就是最小的。一堆的石头重量是sum，那么我们就尽可能拼成重量为sum / 2的石头堆。这样剩下的石头堆也是尽可能接近 sum/2 的重量。那么此时问题就是有一堆石头，每个石头都有自己的重量，是否可以装满最大重量为 sum / 2的背包。

这样就和之前的 416分割等和子集非常像了。

动规五部曲：

1确定dp数组及下标的含义：最多可以背的重量为dp[j]

2确定递归公式：dp[j] = max(dp[j], dp[j - stones[i]] + stones[i]);

3 dp数组初始化：初始化都为0就可以

4遍历顺序：如果使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历。

5举例推导dp数组

java 复制代码

class Solution {
    public int lastStoneWeightII(int[] stones) {
        int sum=0;
        for(int i:stones){
            sum=sum+i;
        }
        int target=sum>>1;

        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-2*dp[target];
    }
}

494目标和

题目：给你一个非负整数数组 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

链接：https://leetcode.cn/problems/target-sum/

假设加法的总和为x，那么减法对应的总和就是sum - x。所以我们要求的是 x - (sum - x) = target，x = (target + sum) / 2。此时问题就转化为，用nums装满容量为x的背包，有几种方法。
1 确定dp数组及其下标含义：

用二维 dp数组求解本题，dp[i][j]使用下标为[0, i]的nums[i]能够凑满j（包括j）这么大容量的包，有dp[i][j]种方法。
2 确定递归公式：

装满背包容量为0 的方法个数是1，即放0件物品。装满背包容量为1 的方法个数是1，即放物品0。装满背包容量为2 的方法个数是0，目前没有办法能装满容量为2的背包。

dp[2][2] = 容量为2的背包不放物品2有几种方法 + 容量为2的背包放物品2有几种方法

不放物品i：即背包容量为j，里面不放物品i，装满有dp[i - 1][j]中方法。

放物品i：即先空出物品i的容量，背包容量为（j - 物品i容量），放满背包有 dp[i - 1][j - 物品i容量] 种方法。

递推公式：dp[i][j] = dp[i - 1][j] + dp[i - 1][j - nums[i]];

注意到j - nums[i] 作为数组下标，那如果 j - nums[i] 小于零呢？说明背包容量装不下物品i，所以此时装满背包的方法值等于不放物品i的装满背包的方法，即：dp[i][j] = dp[i - 1][j];

3 dp数组如何初始化

先明确递推的方向，求解 dp[2][2] 是由上方和左上方推出。那么二维数组的最上行和最左列一定要初始化，这是递推公式推导的基础。

最上行： dp[0][j]只放物品0，把容量为j的背包填满有几种方法。只有背包容量为物品0 的容量的时候，方法为1，正好装满。所以初始化：dp[0][nums[0]] = 1 ，其他均为0 。

最左列： dp[i][0]背包容量为0，放物品0到物品i，装满有几种方法。都是有一种方法，就是放0件物品，即 dp[i][0] = 1。

但这里有例外，就是如果物品数值就是0呢？如果有两个物品，物品0为0，物品1为0，装满背包容量为0的方法有几种。放0件物品，放物品0，放物品1，放物品0 和物品1。此时是有4种方法。其实就是算数组里有t个0，然后按照组合数量求，即 2^t 。

4 确定遍历顺序：从上到下，从左到右。
5 举例推导dp数组。

java 复制代码

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int sum=0;
        for(int i=0;i<nums.length;i++){
            sum=sum+nums[i];
        }
        if(sum<Math.abs(target)){
            return 0;
        }
        if((sum+target)%2!=0){
            return 0;
        }

        int left = (sum + target) / 2;
        int[][] dp=new int[nums.length][left+1];
        if(nums[0]<=left){//初始化最上行
            dp[0][nums[0]]=1;
        }
        int zero=0;
        for(int i=0;i<nums.length;i++){
            if(nums[i]==0){
                zero++;
            }
            dp[i][0]=(int) Math.pow(2,zero); //初始化最左列
        }

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

474一和零

题目：给你一个二进制字符串数组 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 。

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

动规五部曲：
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。然后我们在遍历的过程中，取dp[i][j]的最大值。所以递推公式：dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1);

3 dp数组如何初始化

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

4 确定遍历顺序

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

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

java 复制代码

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数组

java 复制代码

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int[][] dp=new int[m+1][n+1];
        int one,zero;
        for(String str:strs){
            one=0;
            zero=0;
            for(char c:str.toCharArray()){
                if(c=='0'){
                    zero++;
                }else{
                    one++;
                }
            }

            for(int i=m;i>=zero;i--){
                for(int j=n;j>=one;j--){
                    dp[i][j]=Math.max(dp[i][j],dp[i-zero][j-one]+1);
                }
            }
        }
        return dp[m][n];
    }
}