代码随想录算法训练营第 34 天 | 01 背包理论基础 - 二维数组、01 背包理论基础 - 一维数组、416. 分割等和子集

01 背包理论基础 - 二维数组

题目链接

物品数量为 n，背包最大容量 bagWeight

i：第 0~n - 1 个物品
j：0 到 bagWeight 的容量

dp[i][j]：0~i 的物品任意放入容量为 j 的背包，最大的价值

递推公式：dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weights[i]] + values[i])

---

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // 读数据
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int bagWeight = sc.nextInt();
        int[] weights = new int[n]; // 每件物品的重量
        int[] values = new int[n]; // 每件物品的价值
        for (int i = 0; i < n; i++) {
            weights[i] = sc.nextInt();
        }
        for (int i = 0; i < n; i++) {
            values[i] = sc.nextInt();
        }

        // 初始化 dp 数组
        int[][] dp = new int[n][bagWeight + 1];
        for (int i = weights[0]; i <= bagWeight; i++) {
            dp[0][i] = values[0];
        }

        // 开始遍历
        for (int i = 1; i < n; i++) {
            for (int j = 1; j <= bagWeight; j++) {
                if (j < weights[i]) {
                    dp[i][j] = dp[i - 1][j];
                } else {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weights[i]] + values[i]);
                }
            }
        }
        
        System.out.println(dp[n - 1][bagWeight]);
    }
}

for 循环中，i 从 1 开始遍历；j 从 0 或 1 皆可。

---

01 背包理论基础 - 一维数组

dp[j]：容量为 j 的背包的最大价值

递推公式：dp[j] = Math.max(dp[j], dp[j - weights[i]] + values[i])

与二维数组的不同：

1. 初始化全部初始化为 0（dp[0] 是意义上应该为 0，后面的数是为了不太大覆盖后面的结果而设置的一个最小值），所以不用赋值直接新建出数组就好了。
2. 遍历顺序只能先物品后背包容量，且内层循环遍历背包容量时要倒序遍历！

倒序遍历：保证物品只添加 1 次。
因为如果我们从小到大更新 dp 值，那么在计算 dp[j] 值的时候，dp[j−weights[i]] 已经是被更新过的状态，不再是上一行的 dp 值。
 
先背包重量后物品：实际求的是能放入背包的最大一个物品重量。

3. 一处优化：不用再用 if-else 比较 j 与 weights[i] 大小了。

        for (int i = 0; i < n; i++) {
            for (int j = bagWeight; j >= 1; j--) {
                if (j >= weights[i]) {
                    dp[j] = Math.max(dp[j], dp[j - weights[i]] + values[i]);
                }
            }
        }

优化成：

        for (int i = 0; i < n; i++) {
            for (int j = bagWeight; j >= weights[i]; j--) {
                dp[j] = Math.max(dp[j], dp[j - weights[i]] + values[i]);
            }
        }

如果 j 比 weights[i] 还小的话，那么就连物品 i 都放不进去了，那么再去遍历背包容量的话就没有意义了。

4. 一维数组 i 从 0 开始遍历，二维数组 i 从 1 开始遍历（因为初始化时已经遍历过 i = 1 了）；j 遍历到 weights[i]

---

代码：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        // 读数据
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int bagWeight = sc.nextInt();
        int[] weights = new int[n]; // 每件物品的重量
        int[] values = new int[n]; // 每件物品的价值
        for (int i = 0; i < n; i++) {
            weights[i] = sc.nextInt();
        }
        for (int i = 0; i < n; i++) {
            values[i] = sc.nextInt();
        }

        // 初始化 dp 数组
        int[] dp = new int[bagWeight + 1]; // 不用赋值
        
        for (int i = 0; i < n; i++) {
            for (int j = bagWeight; j >= 1; j--) { // 必须倒序遍历
                if (j >= weights[i]) {
                    dp[j] = Math.max(dp[j], dp[j - weights[i]] + values[i]);
                }
            }
        }

        System.out.println(dp[bagWeight]);
    }
}

---

416. 分割等和子集

题目链接

抽象成背包问题，数组中的每一个数字既为重量、又为价值。

target = sum / 2

判断 target 的容量价值是否恰好是 target，即 dp[target] == target

class Solution {
    public boolean canPartition(int[] nums) {
        int n = nums.length;
        int sum = 0;
        for (int x : nums) {
            sum += x;
        }
        if (sum % 2 == 1) {
            return false;
        }
        int target = sum / 2;

        Arrays.sort(nums); // 排序可能会稍微加快点速度
        int[] dp = new int[target + 1];
        for (int i = 0; i < n; i++) {
            for (int j = target; j >= nums[i]; j--) {
                dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i]); // 重量和价值都是 nums[i]
            }
        }

        return dp[target] == target;
    }
}

优化：

1. 求和过程中记录最大值，若最大值比 一半值 target 大，则直接返回 false。简单，略。
2. 官解将 dp 设成 boolean 类型。表示是否存在一种选取方案使得被选取的正整数的和等于 j。

---

背包问题总结

对于 01 背包二维 dp 数组的实现，其遍历顺序可以颠倒。
一维 dp 数组，只能先物品再背包容量，且背包容量要倒序遍历。

一维数组 i 从 0 开始遍历，二维数组 i 从 1 开始遍历

---