day42【动态规划】● 01背包问题 二维 ● 01背包问题 一维 ● 416. 分割等和子集

01背包问题 二维

• 代码随想录 | 背包理论基础
• 背包问题种类：重点是01背包和完全背包

二维dp数组01背包

• 有n件物品和一个最多能背重量为w 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。
• 暴力解法：每一件物品其实只有两个状态，取或者不取，所以可以使用回溯法搜索出所有的情况，那么时间复杂度就是$o(2^n)$，这里的n表示物品数量。时间复杂度为指数级别，需要动态规划进行优化
• 动规五部曲分析：
  1. 确定dp数组的下标和含义
     dp[i][j]：从下标为[0 - i]的物品中任意取，放进容量为j的背包，价值总和最大是多少
  2. 确定递推公式
     有两个方向可以推出dp[i][j]

     • 不放物品i：由dp[i-1][j]推出，即背包容量为j时，里面不放物品i的最大价值，此时dp[i][j]就是dp[i-1][j]。（其实就是当物品i的重量大于背包j的重量时，物品i无法放进背包中，所以背包中的价值仍和上一个相同）

     • 放物品i：由dp[i-1][j - weight[i]]推出，背包容量j-weight[i]的时候不放物品i的最大价值，那么dp[i-1][j - weight[j]] + value[i] 就是背包放入i后的最大价值

       来自b站评论区：当i放进去时，那么这时候整个物品集就被分成两部分，1到i-1和第i个，而这是i是确定要放进去的，那么就把j空间里的wi给占据了，只剩下j－wi的空间给前面i－1，那么只要这时候前面i－1在j－wi空间里构造出最大价值，即dp【i－1】【j－wi】，再加上此时放入的i的价值vi，就是dpij了

     • 所以递归公式为：dp[i][j] = Math.max(dp[i - 1][j], dp[i-1][j - weight[i]] + value[i]]);

  3. 初始化
     • j背包容量为0时，价值总和一定为0.
     • i物品为0时，看背包是否能放的下0.放不下则为0，放得下的就是物品0的价值。
     • 其他元素值都是由i-1推导而来的，或者从左上方推导而来，所以赋值多少都可以。但一般方便起见都赋值为0.
       
  4. 遍历顺序
     元素是由其上方或左上方推导而来，所以先遍历背包还是先遍历物品都可以。
     

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");
        }
    }
}

一维dp数组01背包

• 可以压缩状态，i是由i-1行推导而来的，可以让新的i覆盖原来的i-1，这样就可以只有一行，形成滚动数组。
• 动规五部曲

  1. dp[j] : 容量为j的背包所能放的物品的最大价值。

  2. 递推公式：dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i])
     如果不放i，那就是之前的重量dp[j]，如果放i，就重量需要减去放进去的i的，再加上放进来的i的。其实dp[j - weight[i]]是看，此时把i的重量减去以后，这个背包还剩多少空间，这个空间能装得下前面的谁，如果装得下前面的某个，那就前面的重量+新加的i的重量，肯定比原来的dp[j]大。

  3. 初始化:dp[0]为0，容量为0，所放的价值肯定为0。根据递推公式，每次都要与原来的dp[j]对比取最大值，所以其他元素应该取最小的非负整数，即0.

  4. 遍历顺序：一维dp数组01背包的遍历顺序比较有讲究。
     先遍历物品，再遍历背包。且背包容量需要从大到小遍历。

     背包容量倒序遍历是为了保证每件物品只能被放入一次。如果是正序的话，有可能前面的物品会被重复加入。
     例如：物品0的重量weight[0] = 1，价值value[0] = 15
     dp[1] = dp[1 - weight[0]] + value[0] = 15
     dp[2] = dp[2 - weight[0]] + value[0] = 30

     而倒序就是先算dp[2]

     dp[2] = dp[2 - weight[0]] + value[0] = 15 （dp数组已经都初始化为0）

     dp[1] = dp[1 - weight[0]] + value[0] = 15
     

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

    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] + " ");
        }
    }

416. 分割等和子集

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

• 代码随想录 | 讲解链接

• 给你一个 只包含正整数 的 非空 数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。

    示例 1：
    输入：nums = [1,5,11,5]
    输出：true
    解释：数组可以分割成 [1, 5, 5] 和 [11] 。
    
    示例 2：
    输入：nums = [1,2,3,5]
    输出：false
    解释：数组不能分割成两个元素和相等的子集。
  

• 分析：两个子集的和相等，那么一个子集的和就是nums总和的一半，可抽象为背包容量。把元素放进包里，看能否把背包放满。

• 动规5部曲

  1. dp[j] : 容量为j的背包（总和的一半）所能装的价值，如果把背包装满，其价值应该也是数组总和的一半。也就是此时背包的容量 = 背包的价值，价值和重量等价。

     dp[target] == target 说明背包已经被装满了。target是想要总和的一半，也就是装满后的价值，而dp里的target是背包的容量，也就是容量为target的背包装的价值是target时，说明此时背包已经装满。

  2. 递推公式：dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i])

     但在本题中：数字本身就是重量和价值，因此递归公式为：
     dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i])

  3. 初始化：dp[0] = 0; 非零下标的dp数组，初始为一个非负整数最大值0，因为在递推公式中有dp[j]和后面的进行比较，所以要赋为0，这样不会扰乱结果。

  4. 遍历顺序：先遍历物品，再遍历背包（倒序遍历）

class Solution {
    public boolean canPartition(int[] nums) {
        //先剪枝一次，数组为空或长度为0时返回false
        if(nums.length == 0 || nums == null) return false;
        //计算数组中元素的总和
        int sum = 0;
        for(int num: nums) {
            sum += num;
        }
        //剪枝，如果总和为奇数，则不能返回两个元素和相等的子集
        if(sum % 2 != 0) return false;

        int target = sum / 2;
        int n = nums.length;
        //dp[j]含义为nums为j时dp数组的最大总和，所以得把j最大能取target，所以长度为target+1
        int[] dp = new int[target + 1];
        //从nums数组中第0个位置遍历，把数字放进去
        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]);
            }

            //剪枝一下，每次循环完就检查下是否满足要求，满足后就直接return
            if(dp[target] == target) {
                return true;
            }
        }
        return dp[target] == target;
    }
}