代码随想录Day_43打卡

①、最后一块石头的重量Ⅱ

有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。

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

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

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

事例：

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

 思路：

        跟上一题的组合问题类似，使用动态规划。将石头重量分为两组，求石头尽量装满一半重量的装法。由于重量总和可能是单数，将背包重量限制为总重一半可能会有精度丢失，故在判断中直接求得差值绝对值的最小值即可。

动态规划：

        dp定义及含义：dp[j]表示背包容量为j能装满的最大石头总重

        状态转移方程：dp[j] = Math.max(dp[j],dp[j - stones[i]] + stones[i])

        初始化：dp[0] = 0

        遍历顺序：石头从小到大遍历，背包容量倒序遍历

        求得 sum - 2 * dp[j] 的最小值

代码：

public int lastStoneWeightII(int[] stones) {
        Arrays.sort(stones);
        int sum = 0;
        for(int x : stones){
            sum += x;
        }
        int target = sum / 2;
        int[] dp = new int[target + 1];
        dp[0] = 0;
        int res = Integer.MAX_VALUE;
        for(int i = 0;i < stones.length;i++){
            for(int j = target;j > 0;j--){
                if(j >= stones[i]) dp[j] = Math.max(dp[j],dp[j - stones[i]] + stones[i]);
            }
            res = Math.min(res,Math.abs(sum - 2 * dp[target]));
        }
        return res;
    }

②、目标和

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

思路：

        该题只用到 + - 符号，故可以将数组分成左右两个子集，最终满足left - right = target即可。由于nums的总和固定，left + right = sum，再加上left - right = target，求得left = (target + sum) / 2，故使用背包问题，求得nums组成left总共有多少种组合即可。若target + sum是单数，即 / 2有精度损失则无法满足left - right = target，返回0，若target的绝对值大于sum 也返回0。

动态规划：

        dp定义及含义：dp[j]为满足子集left = j总共有dp[j]种方法

        状态转移方程：dp[j] += dp[j - nums[i]]

        初始化：dp[0] = 1

        遍历顺序：数组正序遍历，背包容量逆序遍历

        dp[left]即为所要求的结果

代码：

public int findTargetSumWays(int[] nums, int target) {
        int sum = 0;
        for(int x : nums){
            sum += x;
        }
        int left = sum + target;
        if(left % 2 != 0 || Math.abs(target) > sum) return 0;
        left /= 2;
        int[] dp = new int[left + 1];
        dp[0] = 1;
        for(int i = 0;i < nums.length;i++){
            for(int j = left;j >= 0;j--){
                if(j >= nums[i]) dp[j] += dp[j - nums[i]];
            }
        }
        return dp[left];
    }

③、一和零

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

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

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

事例：

输入：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 。

思路：

        使用动态规划，跟之前的题目类似，但一和零是两个不同的维度，故可以使用二维背包dp[i][j]，其中i表示有i个0，j表示有j个1，dp[i][j]即表示构成i个0 j个1的最长子集数。由于题目要求的是子集长度，使用当前元素长度加1，故状态转移方程改为dp[i][j] = Math.max(dp[i][j],dp[i - x][j - y] + 1)。其中x,y分别表示当前元素有多少个0和1。

动态规划：

        dp定义及含义：dp[i][j]表示构成i个0和j个1的最长子集数

        状态转移方程：dp[i][j] = Math.max(dp[i][j],dp[i - x][j - y] + 1) 其中x,y分别表示当前元素的01个数。

        初始化：dp[0][0] = 0

        遍历顺序：字符串数组正序遍历，背包容量倒序遍历，两个维度的顺序无所谓

        dp[m][n]即为答案。

代码：

public int findMaxForm(String[] strs, int m, int n) {
        int[][] dp = new int[m + 1][n + 1];
        dp[0][0] = 0;
        for(String str : strs){
            int x = 0;
            int y = 0;
            for(char c : str.toCharArray()){
                if(c == '0') x++;
            }
            y = str.length() - x;
            for(int i = m;i >= x;i--){
                for(int j = n;j >= y;j--){
                    dp[i][j] = Math.max(dp[i][j],dp[i - x][j - y] + 1);
                }
            }
        }
        return dp[m][n];
    }

参考：代码随想录 (programmercarl.com)