每日一题：474一和零、494目标和、1049最后一块石头重量II（动态规划，01背包）

474 一和零

给你一个二进制字符串数组 strs和两个整数 m 和 n 。请你找出并返回 strs 的最大子集的大小，该子集中最多有 m 个 0 和 n 个 1 。

示例 1：

输入：strs = [“10”, “0001”, “111001”, “1”, “0”], m = 5, n = 3
输出：4
解释：最多有 5 个 0 和 3 个 1 的最大子集是 {“10”,“0001”,“1”,“0”} ，因此答案是 4 。

示例 2：

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

思路

问题抽象成01背包问题，选择某个字符串，获得它的0和1的数量，所以这题的目的就是尽可能多的选择字符串，使得0的数量不大于m，1的数量不大于n。
因此可以获得状态转移方程：
$$dp[i][j][k]=\{\begin{array}{l}dp[i-1][j][k]\\ dp[i-1][j-i.zeroNum][k-i.oneNum]+1\end{array}$$
初始化第0行为0，可以避免考虑strs的类别
由于题目给出0,1的范围，所以在进行状态转移时，仅依赖于就j,k的左侧

代码

public int findMaxForm(String[] strs, int m, int n) {
        int[][] dp = new int[m + 1][n + 1];
        int length = strs.length;
        for (int i = 0; i < length; i++) {
            int[] zerosOnes = getZeroAndOne(strs[i]);
            int zeros = zerosOnes[0], ones = zerosOnes[1];
            for (int j = m; j >= zeros; j--) {
                for (int k = n; k >= ones; k--) {
                    dp[j][k] = Math.max(dp[j][k], dp[j - zeros][k - ones] + 1);
                }
            }
        }
        return dp[m][n];
    }

    public int[] getZeroAndOne(String str) { //计算数组每个元素包含的0,1数量
        int[] zerosOnes = new int[2];
        int length = str.length();
        for (int i = 0; i < length; i++) {
            zerosOnes[str.charAt(i) - '0']++;
        }
        return zerosOnes;
    }

494 目标和

给你一个整数数组 nums 和一个整数 target 。

向数组中的每个整数前添加 ‘+’ 或 ‘-’ ，然后串联起所有整数，可以构造一个 表达式 ：

例如，nums = [2, 1] ，可以在 2 之前添加 ‘+’ ，在 1 之前添加 ‘-’ ，然后串联起来得到表达式 “+2-1” 。

返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。

示例
输入：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

思路

建立状态转移方程：
$$dp[i][j]=dp[i-1][j-nums[i]]+dp[i-1][j+nums[i]]$$
状态转移时要考虑到元素可加可减，同时nums[0]=0，加0减0都不会影响结果，因此对dp数组的初始化也很重要。

代码

public static int findTargetSumWays(int[] nums, int s) {
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        if (Math.abs(s) > Math.abs(sum)) return 0;

        int l = nums.length;
        // - 0 +
        int m = sum * 2 + 1;//有正有负
        int[][] dp = new int[l][m];
        // 初始化
        dp[0][sum + nums[0]] = 2 - (nums[0]==0? 0:1);
        dp[0][sum - nums[0]] = 2 - (nums[0]==0? 0:1);
        
        for (int i = 1; i < len; i++) {
            for (int j = 0; j < t; j++) {
                // 边界
                int l = (j - nums[i]) >= 0 ? j - nums[i] : 0;
                int r = (j + nums[i]) < t ? j + nums[i] : 0;
                dp[i][j] = dp[i - 1][l] + dp[i - 1][r];
            }
        }
        return dp[len - 1][sum + s];
    }

1049最后一块石头重量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]，这就是最优值。

思路
这题把思路转到01背包简直就是在做脑筋急转弯！
学习了大佬的思路，分成两堆，求差值最小

代码

public int lastStoneWeightII(int[] stones) {
        int sum = 0;
        for(int i = 0; i < stones.length; i++) {
            sum += stones[i];
        }
        int[][] dp = new int[stones.length+1][sum/2+1];
         for(int i=1;i<=stones.length;i++){
            for(int j=0;j<=sum/2;j++){
                //当我能把这块石头放进背包时，我会比较放或不放，选择最大值
                if(j>=stones[i-1]){
                    dp[i][j] = Math.max(dp[i-1][j],dp[i-1][j-stones[i-1]] + stones[i-1]);
                } else {
                //这块石头放不进背包时，只能跳过
                    dp[i][j] = dp[i-1][j];
                }
            }
        }
        //dp[stones.length][sum/2]的最大值为sum/2，因此最理想的结果为0
        return sum-dp[stones.length][sum/2]*2;
    }