【代码训练营】day42 | 1049. 最后一块石头的重量 II & 494. 目标和 & 474.一和零

所用代码 java

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

题目链接：最后一块石头的重量II LeetCode 1049 - 中等

思路

无。

---

把石头分成重量总和近似两堆，然后两堆石头相撞，剩下的就是最小的石头。每个石头只能用一次，01背包！

• dp[j] ： 装满容量为 j 背包，最大重量为dp[j]
• 递推公式：dp[j] = max(dp[j], dp[j-stones[i]] + stones[i])
• 初始化：dp[0] = 0，非零下标 0 背包容量由题意，最多30块石头，每个价值不超过100，所以容量最大3000/2= 1500，即背包的容量可以定义为dp[1501]
• 遍历方向：0<=i

class Solution {
    public int lastStoneWeightII(int[] stones) {
        int sum = 0;
        for (int stone : stones) {
            sum += stone;
        }
        int target = sum / 2; // 向下取整
        // leetcode最大3000
        int[] dp = new int[1501];
        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]);
            }
        }
        // 由于target是向下取整的，所以
        // 大的一堆：sum - dp[target] 小的一堆： dp[target]
        return sum - dp[target] - dp[target];
    }
}

二维数组：

• dp[i] [j]： 放[0 - i]个石头，在背包容量为j的情况下的最大重量
• 初始化： dp[i] [0]背包为零，重量为零 ， dp[0] [j] 下标为0的石头取决于背包大于等于stones[0]时可以装下

class Solution {
    public int lastStoneWeightII(int[] stones) {
        int sum = 0;
        for (int stone : stones) {
            sum += stone;
        }
        int target = sum / 2; // 向下取整

        // 初始化
        int[][] dp = new int[stones.length][target + 1];
        for (int j = stones[0]; j<= target; j++) {
            dp[0][j] = stones[0];
        }
        // 外层 石头
        for (int i = 1; i < stones.length; i++) {
            // 内层 背包
            for (int j = 1; j <= target; j++) {
                // 下一块石头装不下，最大重量就是上一块石头的
                if (j < stones[i]){
                    dp[i][j] = dp[i-1][j];
                }else {
                    dp[i][j] = Math.max(dp[i-1][j], dp[i-1][j-stones[i]] + stones[i]);
                }
            }
        }
//        System.out.println("dp[stones.length-1][target] = " + dp[stones.length-1][target]);
        return sum - dp[stones.length-1][target] - dp[stones.length-1][target];
    }
}

总结

同样这题分析，看到这种两两成对的放东西，而且一种物品只能放一个一般都是01背包问题，分析清楚问题才好对症下药。

目标和 LeetCode 494

题目链接：目标和 LeetCode 494 - 中等

思路

无。

---

分成两个集合，一个集合放加法，一个集合放减法：

left + right = sum left - right = target right = sum - left => left = (target + sum) / 2

集合里面挑出正数的集合等于(target + sum) / 2，剩下的就是负数的集合， 不能整除，就证明凑不成集合。

所以这题抽象成 背包容量为(target + sum) / 2，判断集合有多少种装满的情况

• dp[j]：装满背包容量为j的背包，有dp[j]种方法
• 递推公式：dp[j] += dp[j-nums[i]]
• 初始化：dp[0] = 1 (空集也是一种方法) 非零下标初始为0
• 遍历顺序：物品：0<=i< nums.length 背包 bagSize=j>=nums[i]

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int sum = 0;
        for (int num : nums) sum+=num;
        // 背包（正数）不能是小数或负数
        if ((target + sum) % 2 == 1 || (target + sum) / 2 < 0) return 0;
        int bagSize = (target + sum) / 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]];
//                System.out.print("dp[j]=" + dp[j] + "\t");
            }
//            System.out.println();
        }
        return dp[bagSize];
    }
}

二维数组：

• dp[i] [j]：从[0-i]挑选出的放+数字，恰好装满和为j的背包，有dp[i] [j]种

• 递归公式：dp[i] [j] = dp[i-1] [j] + dp[i-1] [j-nums[i]]

  • 上一轮挑选出来的的和，本轮未挑选：dp[i-1] [j]
  • 上一轮加本轮挑选：dp[i-1] [j-nums[i]]

• 初始化：dp[0] [0] = 1 ，dp[i] [0] = 0，

  ​ dp[0] [j] 装nums[0]只有j= nums[0]这一种方法，dp[0] [nums[0]] = 1

class Solution {
    public int findTargetSumWays(int[] nums, int target) {
        int sum = 0;
        for (int num : nums) sum+=num;
        // target的绝对值大于sum，证明背包的数怎么都没法凑成sum
        if (Math.abs(target) > sum) return 0;
        if ((target + sum) % 2 == 1) return 0;
        int bagSize = (target + sum) / 2;

        // 初始化 - 新开一个物品维度，以防止初始化0的情况
       int[][] dp = new int[nums.length + 1][bagSize + 1];
       // 物品维度为0的物品，不一定是0
       dp[0][0] = 1;
        // 只放第0个物品，只有背包容量为nums[0]刚好放下
        if (nums[0] <= bagSize) dp[1][nums[0]] = 1;

       // 外层 物品
        for (int i = 1; i < nums.length + 1; i++) {
            // 内层 背包 
            // 从0开始遍历是因为我们只初始化了一个点, j=0的情况没有初始化
            for (int j = 0; j <= bagSize; j++) {
                if (j < nums[i-1]){
                    // 不会放入背包
                    dp[i][j] = dp[i-1][j];
                }else {
                    // 可以放入背包 = i-1物品放入背包的数量 +
                    // i-1物品放入背包的数量+再放入nums[i]的物品的最大数量
                    dp[i][j] = dp[i-1][j] + dp[i-1][j-nums[i-1]];
                }
//                System.out.print("\tdp[i][j] = " + dp[i][j]);
            }
//            System.out.println();
        }
        return dp[nums.length][bagSize];
    }
}

总结

背包容量和价值用一个数表示的话，使用一维数组更加方便，只是我们在遍历的时候从后往前遍历行了，以免前面的数据被覆盖。

一和零 LeetCode 474

题目链接：一和零 LeetCode 474 - 中等

思路

无。

---

• dp[i] [j]：装满i个0j个1，最多背dp[i] [j] 个物品
• 递推公式：dp[j] = max(dp[j], dp[j-weight[i]] + value[i])
  • m个0，n个1：dp[i] [j] = max(dp[i] [j], dp[i-x] [j-y] + 1)
  • 加1是物品的价值可看作1，因为每次可以多放一个
• 初始化：dp[0] [0] = 0 ，非0下标也该初始化为0
• 遍历顺序：str=> 统计每个物品有多少个0 1 => 物品重量
  • i=m i>=x 背包容量，这两个顺序可以颠倒
  • j=n j>=y

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int[][] dp = new int[m + 1][n + 1];
        // x表示0的个数，y表示1的个数
        int x, y;
        // 遍历每一个物品
        for (String str : strs) {
            x = 0;
            y = 0;
            // 统计x和y的重量，也就是出现的个数
            for (char c : str.toCharArray()){
                if (c == '0') x++;
                else y++;
            }

            // 相当于滚动二维倒叙遍历
            for (int i = m; i >= x; i--){   // 0的个数
                for (int j = n; j >= y; j--){   // 1的个数
                    dp[i][j] = Math.max(dp[i][j], dp[i-x][j-y] + 1);
                }
            }
        }
        return dp[m][n];
    }
}

总结

本题元素就是物品，每个物品只有一个，所以dp[i-x] [j-y] + 1 这里才是 + 1，就是选了一个物品。