Leetcoder Day38｜ 动态规划part05 背包问题

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

有一堆石头，每块石头的重量都是正整数。

每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

如果 x == y，那么两块石头都会被完全粉碎；

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

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

示例：

• 输入：[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]，这就是最优值。

提示：

• 1 <= stones.length <= 30
• 1 <= stones[i] <= 1000

本题要求最小的石头重量，最好的情况就是最后剩下的两个石头重量一致，结果为0。那也就跟昨天的分割子集的本质一样，将这个数组分割成两个子集，使得两个子集的元素和相等。因此看是否可以将石头重量集合拆分为总和为sum/2的子集。因为本题石头粉碎是不可逆的，因此属于01背包问题，那么就开始对应如下四点：

• 背包的可容纳的重量为sum / 2
• 背包要放入的石头的重量也就是石头的价值
• 背包如果正好装满，说明找到了总和为 sum / 2 的子集。
• 背包中每一个元素是不可重复放入

动规五部曲：

1. 确定dp数组以及下标的含义：dp[j]表示重量为j的背包，最多可以背的重量为dp[j]
2. 确定递推公式：dp[j]=max(dp[j], dp[j-stones[i]]+stones[i])
3. dp数组如何初始化：sum+=stones[i] target=sum/2
4. 递归顺序：先遍历石头，再遍历重量，并且重量要倒序遍历

如果背包需要满足的容量为target，当dp[target]==target时，背包就装满了，也就是本题的结果为0。如果不能满足，因为sum/2是向下取整，所以sum-dp[target]一定大于dp[target]，所以相撞以后剩下的石头重量为(sum-dp[target])-dp[target]

class Solution {
    public int lastStoneWeightII(int[] stones) {
        int sum=0;
        for(int i=0;i<stones.length;i++){
            sum+=stones[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-dp[target])-dp[target]; 
    }
}

注意：这里不需要再单独判断一下dp[target]是否等于target了，如果等于的话，其实最后相当于sum-2*target=0了，如果多写了这一步判断，反而会漏算情况。

并且sum/2的空间复杂度要比sum>>1，移位运算高，所以最好写后者。

494.目标和

给定一个非负整数数组，a1, a2, ..., an, 和一个目标数，S。现在你有两个符号 + 和 -。对于数组中的任意一个整数，你都可以从 + 或 -中选择一个符号添加在前面。

返回可以使最终数组和为目标数 S 的所有添加符号的方法数。

示例：

• 输入：nums: [1, 1, 1, 1, 1], S: 3
• 输出：5

解释：

• -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

一共有5种方法让最终目标和为3。

提示：

• 数组非空，且长度不会超过 20 。
• 初始的数组的和不会超过 1000 。
• 保证返回的最终结果能被 32 位整数存下。

这道题先用动态规划五部曲想了一下：本题依然是只能取一次，所以还是01背包思路

1. 确定dp数组以及下标的含义：dp[j]表示达到和为j的值有dp[j]种方法
2. 确定递推公式：目前还不知道
3. dp数组如何初始化：dp[0]=1，因为当只有1个元素的时候，那么就只有一种方法
4. 确定遍历顺序：还是按照元素从前向后，按照数值从后向前
5. 举例推导dp数组：递推公式还没出来，暂时举不出来例子

脑子比较累，直接看了题解：

本题要如何使表达式结果为target。首先因为有sum，所以left + right = sum，sum是固定的，因此right = sum - left。既然为target，那么就一定有  left组合 - right组合 = target，这里left就是加法的总和，right就是减法的总和，公式来了， left - (sum - left) = target 推导出 left = (target + sum)/2, target是固定的，sum是固定的，left就可以求出来。此时问题就是在集合nums中找出和为left的组合。此时问题就转化为，装满容量为left的背包，有几种方法。还要注意几种特殊的情况：(target + sum) / 2 应该担心计算的过程中向下取整有没有影响，如果sum为5，target为2，那么无论怎样也不会到达target值，也就是说当sum+target为奇数时，是没有解决方案的。并且如果target的的绝对值大于sum，也是没有解决方法的，直接返回0。

只要搞到nums[i]，凑成dp[j]就有dp[j - nums[i]] 种方法。

例如：dp[j]，j 为5，

• 已经有一个1（nums[i]） 的话，有 dp[4]种方法 凑成 容量为5的背包。
• 已经有一个2（nums[i]） 的话，有 dp[3]种方法 凑成 容量为5的背包。
• 已经有一个3（nums[i]） 的话，有 dp[2]中方法 凑成 容量为5的背包
• 已经有一个4（nums[i]） 的话，有 dp[1]中方法 凑成 容量为5的背包
• 已经有一个5 （nums[i]）的话，有 dp[0]中方法 凑成 容量为5的背包

那么凑整dp[5]有多少方法呢，也就是把 所有的 dp[j - nums[i]] 累加起来。

所以求组合类问题的公式，都是类似这种：dp[j] += dp[j - nums[i]]

import java.lang.Math;
class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int sum=0;
        for(int i=0;i<nums.length;i++){
            sum+=nums[i];
        }
        int left=(sum+target)>>1;
        if((sum+target)%2==1) return 0;
        if(Math.abs(target)>sum) return 0;
        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];
    }
}

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 。

示例 2：

• 输入：strs = ["10", "0", "1"], m = 1, n = 1
• 输出：2
• 解释：最大的子集是 {"0", "1"} ，所以答案是 2 。

提示：

• 1 <= strs.length <= 600
• 1 <= strs[i].length <= 100
• strs[i] 仅由 '0' 和 '1' 组成
• 1 <= m, n <= 100

本题还是一个背包问题，本题中strs 数组里的元素就是物品，每个物品都是一个，只能取一次，因此还是01背包问题。这里限制了两个元素的大小，这两个大小之间是没有什么制约关系的，相当于有两个背包，所以要定义一个二维dp数组dp[i][j]继续开始动规五部曲：

1. 确定dp数组以及下标的含义：dp[i][j]表示最多取i个1和j个0后的最大子集的大小
2. 确定递推公式：dp[i][j]是由前一个已经选好的子串推导而来，假设前面那个子串已经有zero个0和one个1，那么dp[i][j]=dp[i-zero][j-one]+1，并且还要跟自己做比较，取最大值。
3. dp数组如何初始化：初始化为0
4. 确定遍历顺序：遍历物品要从前往后，遍历背包要从后往前，这里m和n都是背包，所以都是从后往前遍历。
5. 举例推导dp数组：以输入：["10","0001","111001","1","0"]，m = 3，n = 3为例，最后dp数组的状态如下所示：
    

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