动态规划——01背包

1. 经典“01背包”

经典的“01背包”问题描述如下：有 N 件物品和一个最多能被重量为 W 的背包。第i件物品的重量是 weight[i]，得到的价值是 value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。

动归五部曲分析一下：

1. 确定 dp 数组及下标的含义

• dp[j] 表示背包容量为 j 时，能获得的最大价值。（这里直接省略二维数组直接进行一维数组的讲解）

2. 确定递推公式

• 根据第一步 dp 数组的定义可知，当我们遍历到第 i 个物品时，可以选择将第 i 个物品装入背包，也可以选择不装，这两种情况分别所对应的最大价值如下：
  • 装入：dp[j] = dp[j - weight[i]] + value[i] —— 如果装入第 i 个物品，则在装入之前需要背包先空出第 i 个物品的容量 weight[i]，此时背包所获的的最大价值为 dp[j - weight[i]]，然后再加上第 i 个物品的价值 value[i]
  • 不装：dp[j] = dp[j] —— 如果不装入第 i 个物品，就用除第 i 个物品之外的其它物品填满容量为 j 的背包，此时的最大价值就是 dp[j]
• 最终 dp[j] 取装入或者不装入第 i 个物品所获得的价值中最大的那个，即dp[j] = max(dp[j], dp[j - weight[i]] + value[i])

3. 初始化

• 初始化是严格按照dp 数组的定义来的，当 j 为0时，背包的容量为0，所能获取的最大价值 dp[j] 也是0

5. 确定遍历顺序

• 为了方便理解，也为了与 “01背包” 物品只能取一次的限定吻合，我们外层遍历物品，内层倒序遍历背包容量 。这里为什么要倒序遍历背包容量呢？由递推公式 dp[j] = max(dp[j], dp[j - weight[i]] + value[i]) 可知，我们在计算大容量 dp[j] 时，需要用到小容量 dp[j - weight[i]] 的值，如果在更新大容量之前改变了小容量的值，那么最终的大容量肯定也会受影响，所以我们选择将容量从大到小遍历。

for(int i = 0; i < weight.size(); i++) { // 遍历物品
    for(int j = bagWeight; j >= weight[i]; j--) { // 遍历背包容量
        dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
    }
}

6. 举例推导 dp 数组

假如背包的容量为4，物品的重量和价值如下表：

物品	重量	价值
物品0	1	15
物品1	3	20
物品2	4	30

整体代码示例：

public static void testWeightBagProblem(int[] weight, int[] value, int bagWeight){
    int wLen = weight.length;
    //定义dp数组：dp[j]表示背包容量为j时，能获得的最大价值
    int[] dp = new int[bagWeight + 1];
    //遍历顺序：先遍历物品，再遍历背包容量
    for (int i = 0; i < wLen; i++){
        for (int j = bagWeight; j >= weight[i]; j--){
            dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);
        }
    }
    //打印dp数组
    for (int j = 0; j <= bagWeight; j++){
        System.out.print(dp[j] + " ");
    }
}

---

2. “01背包”方法归纳

其实“01背包”问题最难的是将原问题转化到“01背包”这个模型上来，然后再按照“01背包”的套路进行解题。一般遇到以下问题，优先考虑“01背包”：一堆东西（一组数），按照一定的方式进行组合、处理，能否凑成某种最值状态，或者凑成某种状态的方法数。

通用的动归5部曲：

1. dp 数组的定义：int[] dp = new int[bagSize];
2. dp[j] 递推公式：
   • 如果求背包能装的最大重量：dp[j] = Math.max(dp[j], dp[j - nums[i]]);
   • 如果求装满容量为 j 的背包的方法数：dp[j] = dp[j] + dp[j - nums[i]];
3. dp 数组初始化，按照dp 数组的定义对一些边界值进行初始化
4. 遍历顺序：物品正序，背包倒序（防止物品多次放入）
5. 举例推导 dp 数组，验证前四步的正确性

---

3. 实战

3.1 分割等和子集

LeetCode链接：416. 分割等和子集

给你一个 只包含正整数的非空数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。
示例 1：
输入：nums = [1,5,11,5]
输出：true
解释：数组可以分割成 [1, 5, 5] 和 [11] 。
示例 2：
输入：nums = [1,2,3,5]
输出：false
解释：数组不能分割成两个元素和相等的子集。
提示：
1 <= nums.length <= 200
1 <= nums[i] <= 100

• 思路：假设原数组内数字总和为 sum，若分成两个子集的元素和相等，则每个子集和为 sum / 2，该问题转化为“是否能从非空数组 nums 中选出一些数，这些数的和能够达到sum / 2 “。这就有点”01背包“内味了，我们想想背包问题的原意是求背包能装的最大价值，那转化到这道题上，如果组成子集的元素和最大为sum / 2 是不是也可以呢？当然可以！那就按照动归五步曲来了：

1. 定义 dp 数组：dp[j] 表示容量为 j 的子集，和最大为 dp[j]。
2. 递推公式：dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]) 假设当子集的容量为 j 时，此时遍历到数组的第 i 个数，那我们有两种选择：
   • 第一个选择：将第 i 个数字加入子集：此时能得到的最大和等于容量为 j - nums[i] 的子集能获得的最大价值加上 第 i 个数字的价值，即 dp[j - nums[i]] + nums[i]
   • 第二个选择：不将第 i 个数字加入子集：保持现有的最大和 dp[j] （可以想象成物品太大，无法装入背包，背包内的价值保持原样）
   • 综合上述两种情况，则 dp[j] = max(dp[j], dp[j - nums[i]] + nums[i])
3. 确定初始值：初始化的时候一定要从 dp 数组的定义出发，选择一些不能通过递推公式得到或者递推公式所依赖的那些值（边界值）进行初始化。比如该题中，当子集容量为0的时候，子集内元素最大和也为0，即 dp[0] = 0
4. 确定递推顺序：由于我们已经降维成一维数组，所以子集容量需要从大到小遍历，防止上一层的 dp[j - nums[i]] 被修改。这里想不明白的同学，建议手动画下递推数组。
5. 举例推导 dp 数组
   

• 代码如下：

public boolean canPartition(int[] nums) {
    int sum = 0;
    for (Integer num : nums) {
        sum += num;
    }
    // 和为奇数，不能分为两个和一样的子集
    if ((sum & 1) == 1) return false;
    int target = sum / 2;
    // dp[j] 容量为j的子集所能凑成的最大和
    int[] dp = new int[target + 1];
    // 数组中的数字一个一个填，背包一点一点扩大
    for (int i = 0; i < nums.length; i++) {
        for (int j = target; j >= nums[i]; j--) {
            dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i]);
            // 找到结果提前返回
            if (dp[target] == target) return true;
        }
    }

    return false;
}

---

3.2 最后一块石头的重量 II

LeetCode链接：1049. 最后一块石头的重量 II

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

• 思路：题目说的是从一堆石头中每次拿出两颗进行碰撞（碰撞完剩余 |x-y| 的重量），直至最终剩余的石头重量最小。那我们是否可以将这一堆石头分成重量尽可能相等的两堆，然后直接拿这两堆石头进行碰撞，效果是不是和每次只拿两块石头碰撞一样？答案是肯定的！所以问题就转化为求石头能分为尽可能相等的两堆的重量，我们索性就用容量为 sum / 2 的背包去装石头，看最多能装多少，那么剩余的石头与背包内的石头相碰撞，剩余的重量就为最少。看，我们又把问题转化为 “0-1 背包” 问题了。动归五部曲如下：

1. 定义 dp 数组：dp[j] 表示容量为 j 的背包，能装的石头最重的重量为 dp[j]。
2. 递推公式：dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]) 假设当背包的容量为 j 时，此时遍历到石头堆的第 i 个石头，我们有两种选择：
   • 第一个选择：将第 i 个石头加入背包：此时能得到的最大重量等于容量为 j - nums[i] 的背包能获得的最大重量加上 第 i 个石头的重量，即 dp[j - nums[i]] + nums[i]
   • 第二个选择：不将第 i 个石头加入背包：保持现有的最大重量 dp[j] （可以想象成石头太重，无法装入背包，背包内的重量保持原样）
   • 综合上述两种情况，则 dp[j] = max(dp[j], dp[j - nums[i]] + nums[i])
3. 确定初始值：初始化的时候一定要从 dp 数组的定义出发，选择一些不能通过递推公式得到或者递推公式所依赖的那些值（边界值）进行初始化。比如该题中，当背包容量为0的时候，背包内最终重量也为0，即 dp[0] = 0
4. 确定递推顺序：由于我们已经降维成一维数组，所以背包容量需要从大到小遍历，防止上一层的 dp[j - nums[i]] 被修改。这里想不明白的同学，建议手动画下递推数组。
5. 举例推导 dp 数组
   

• 代码

class Solution {
    public int lastStoneWeightII(int[] stones) {
        // 两堆石头尽可能同样重，这样碰撞之后剩余的重量才会尽可能小
        if (stones == null || stones.length == 0) {
            throw new IllegalArgumentException();
        }

        int sum = Arrays.stream(stones).sum();
        int target = sum / 2;
        // dp[j] 表示容量为 j 的背包能装的最大石头重量
        // dp[j] = Math.max(dp[j], dp[j - stones[i]] + stones[i])
        int[] dp = new int[target + 1];
        // dp[0] = 0;
        for (int stone : stones) {
            for (int j = target; j >= stone; j--) {
                dp[j] = Math.max(dp[j], dp[j - stone] + stone);
            }
        }
        // 最终一堆石头的重量为 dp[target]，另一堆石头的重量为 sum - dp[target]，它们碰撞完剩余的重量为 sum - dp[target] * 2
        return sum - (dp[target] << 1);
    }
}

• 时间复杂度：O(N * Sum)
• 空间复杂度：O(Sum)

---

3.3 目标和

LeetCode链接：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
示例 2：
输入：nums = [1], target = 1
输出：1
提示：
1 <= nums.length <= 20
0 <= nums[i] <= 1000
0 <= sum(nums[i]) <= 1000
-1000 <= target <= 1000

---

3.4 一和零

LeetCode链接：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

---

3.5 盈利计划

LeetCode链接：879. 盈利计划

集团里有 n 名员工，他们可以完成各种各样的工作创造利润。
第 i 种工作会产生 profit[i] 的利润，它要求 group[i] 名成员共同参与。如果成员参与了其中一项工作，就不能参与另一项工作。
工作的任何至少产生 minProfit 利润的子集称为 盈利计划 。并且工作的成员总数最多为 n 。
有多少种计划可以选择？因为答案很大，所以 返回结果模 10^9 + 7 的值。
示例 1：
输入：n = 5, minProfit = 3, group = [2,2], profit = [2,3]
输出：2
解释：至少产生 3 的利润，该集团可以完成工作 0 和工作 1 ，或仅完成工作 1 。
总的来说，有两种计划。
示例 2：
输入：n = 10, minProfit = 5, group = [2,3,5], profit = [6,7,8]
输出：7
解释：至少产生 5 的利润，只要完成其中一种工作就行，所以该集团可以完成任何工作。
有 7 种可能的计划：(0)，(1)，(2)，(0,1)，(0,2)，(1,2)，以及 (0,1,2) 。
提示：
1 <= n <= 100
0 <= minProfit <= 100
1 <= group.length <= 100
1 <= group[i] <= 100
profit.length == group.length
0 <= profit[i] <= 100

---

参考

• 代码随想录