代码随想录算法训练营第四十二天 | 01 背包问题（二维）、01 背包问题（一维）、416. 分割等和子集

代码随想录算法训练营第四十二天 | 01 背包问题（二维）、01 背包问题（一维）、416. 分割等和子集

背包问题分类

01 背包问题

概念： 有 n 件物品和一个最多能背重量为 w 的背包。第 i 件物品的重量是 weight[i]，得到的价值是 value[i]。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。

暴力解法

每一件物品其实只有两个状态，取或者不取，所以可以使用回溯法搜索出所有的情况，那么时间复杂度就是o(2ⁿ)，这里的 n 表示物品数量。所以暴力的解法是指数级别的时间复杂度，进而才需要动态规划的解法来进行优化。

动态规划解法（二维）

采用动规五部曲进行分析：

1. 确定dp数组以及下标的含义
   对于背包问题，一种写法是使用二维数组，即 dp[i][j] 表示从下标为 [0 - i] 的物品里任意取，放进容量为 j 的背包，价值总和最大是多少，如图所示
2. 确定递推公式
   根据 dp 数组的定义可知 dp[i][j] 由两个方向推出，分别为左上方和正上方，对应放物品 i 和不放物品i
   不放物品 i： 由 dp[i - 1][j] 推出，即背包容量为 j，里面不放物品 i 的最大价值，此时 dp[i][j]就是 dp[i - 1][j]。(其实就是当物品 i 的重量大于背包 j 的重量时，物品 i 无法放进背包中，所以背包内的价值依然和前面相同。)
   放物品 i： 由 dp[i - 1][j - weight[i]] 推出，dp[i - 1][j - weight[i]] 为背包容量为 j - weight[i] 的时候不放物品 i 的最大价值，那么 dp[i - 1][j - weight[i]] + value[i] （物品i的价值），就是背包放物品 i 得到的最大价值。
3. dp数组如何初始化
   
   对于其他下标，从递归公式 dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]) 可以看出dp[i][j] 是由左上方数值推导出来了，那么其他下标初始为什么数值都可以，因为都会被覆盖。但只不过一开始就统一把 dp 数组统一初始为 0 更方便一些。
4. 确定遍历顺序（重点）
   对于二维数组，先遍历物品或先遍历背包都可以，因为 dp[i][j] 所需要的数据就是左上角（包括正上方），遍历顺序根本不影响 dp[i][j] 的推导。
5. 举例推导dp数组
   

// 版本一
public class BagProblem {
    public static void main(String[] args) {
        int[] weight = {1,3,4};
        int[] value = {15,20,30};
        int bagSize = 4;
        testWeightBagProblem(weight,value,bagSize);
    }

    /**
     * 动态规划获得结果
     * @param weight  物品的重量
     * @param value   物品的价值
     * @param bagSize 背包的容量
     */
    public static void testWeightBagProblem(int[] weight, int[] value, int bagSize){

        // 创建dp数组
        int goods = weight.length;  // 获取物品的数量
        int[][] dp = new int[goods][bagSize + 1];

        // 初始化dp数组
        // 创建数组后，其中默认的值就是0
        for (int j = weight[0]; j <= bagSize; j++) {
            dp[0][j] = value[0];
        }

        // 填充dp数组
        for (int i = 1; i < weight.length; i++) {
            for (int j = 1; j <= bagSize; j++) {
                if (j < weight[i]) {
                    /**
                     * 当前背包的容量都没有当前物品i大的时候，是不放物品i的
                     * 那么前i-1个物品能放下的最大价值就是当前情况的最大价值
                     */
                    dp[i][j] = dp[i-1][j];
                } else {
                    /**
                     * 当前背包的容量可以放下物品i
                     * 那么此时分两种情况：
                     *    1、不放物品i
                     *    2、放物品i
                     * 比较这两种情况下，哪种背包中物品的最大价值最大
                     */
                    dp[i][j] = Math.max(dp[i-1][j] , dp[i-1][j-weight[i]] + value[i]);
                }
            }
        }

        // 打印dp数组
        for (int i = 0; i < goods; i++) {
            for (int j = 0; j <= bagSize; j++) {
                System.out.print(dp[i][j] + "\t");
            }
            System.out.println("\n");
        }
    }
}

// 版本二
import java.util.Arrays;

public class BagProblem {
    public static void main(String[] args) {
        int[] weight = {1,3,4};
        int[] value = {15,20,30};
        int bagSize = 4;
        testWeightBagProblem(weight,value,bagSize);
    }

    /**
     * 初始化 dp 数组做了简化(给物品增加冗余维)。这样初始化dp数组，默认全为0即可。
     * dp[i][j] 表示从下标为[0 - i-1]的物品里任意取，放进容量为j的背包，价值总和最大是多少。
     * 其实是模仿背包重量从 0 开始，背包容量 j 为 0 的话，即dp[i][0]，无论是选取哪些物品，背包价值总和一定为 0。
     * 可选物品也可以从无开始，也就是没有物品可选，即dp[0][j]，这样无论背包容量为多少，背包价值总和一定为 0。
     * @param weight  物品的重量
     * @param value   物品的价值
     * @param bagSize 背包的容量
     */
    public static void testWeightBagProblem(int[] weight, int[] value, int bagSize){

        // 创建dp数组
        int goods = weight.length;  // 获取物品的数量
        int[][] dp = new int[goods + 1][bagSize + 1];  // 给物品增加冗余维，i = 0 表示没有物品可选

        // 初始化dp数组，默认全为0即可
        // 填充dp数组
        for (int i = 1; i <= goods; i++) {
            for (int j = 1; j <= bagSize; j++) {
                if (j < weight[i - 1]) {  // i - 1 对应物品 i
                    /**
                     * 当前背包的容量都没有当前物品i大的时候，是不放物品i的
                     * 那么前i-1个物品能放下的最大价值就是当前情况的最大价值
                     */
                    dp[i][j] = dp[i - 1][j];
                } else {
                    /**
                     * 当前背包的容量可以放下物品i
                     * 那么此时分两种情况：
                     *    1、不放物品i
                     *    2、放物品i
                     * 比较这两种情况下，哪种背包中物品的最大价值最大
                     */
                    dp[i][j] = Math.max(dp[i - 1][j] , dp[i - 1][j - weight[i - 1]] + value[i - 1]);  // i - 1 对应物品 i
                }
            }
        }

        // 打印dp数组
        for(int[] arr : dp){
            System.out.println(Arrays.toString(arr));
        }
    }
}

动态规划解法（一维——滚动数组）

该解法是在二维的基础上对 dp 数组进行压缩，因此基本思想是一致的，参照下方讲解：
代码随想录——01 背包一维解法
注：重点看遍历顺序

416. 分割等和子集

题目链接：416. 分割等和子集

动态规划算法

思路：本题可以抽象为 01 背包问题，数组中的每个元素相当于一个物品，其值既是物品的价值也是其重量。

1. 确定 dp 数组以及下标的含义： dp[j] 代表容量为 j 的背包所装物品的最大价值；
2. 确定递推公式： 参考 01 背包的一维解法，dp[j] = Math.max(dp[j - 1], dp[j - weight[j]] + value[j])，可知本题的递推公式为 dp[j] = Math.max(dp[j - 1], dp[j - nums[j]] + nums[j])；
3. dp数组如何初始化 从dp[j]的定义来看，首先 dp[0] 一定是 0。如果题目给的价值都是正整数那么非 0 下标都初始化为 0 就可以了；如果题目给的价值有负数，那么非 0 下标就要初始化为负无穷。这样才能让 dp 数组在递推的过程中取得最大的价值，而不是被初始值覆盖了。本题题目中只包含正整数的非空数组，所以非 0 下标的元素初始化为 0 就可以了。
4. 确定遍历顺序 参考 01 背包一维解法的遍历顺序，必须先遍历物品再遍历背包。
5. 举例推导dp数组 如图所示

class Solution {
    public boolean canPartition(int[] nums) {
        if(nums == null || nums.length == 0) return false;
        // 确定背包容量
        int sum = 0;
        for(int num : nums) {
            sum += num;
        } 
        if(sum % 2 != 0) return false; // 若总和为奇数，代表不能平分
        int target = sum / 2;
        
        // 1.确定 dp 数组及下标含义
        int[] dp = new int[target + 1];
        // 3.初始化 dp 数组
        dp[0] = 0;
        // 4.确定遍历顺序
        for(int i = 0; i < nums.length; i++) {
            for(int j = target; j >= nums[i]; j--) { // 注意倒序
                // 2.确定递推公式
                dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i]);
            }
            //剪枝一下，每一次完成内层循环，都检查是否可以返回结果
            if(dp[target] == target)
                return true;
        }

        // 5.打印 dp 数组（debug 用）

        return dp[target] == target;
    }
}