【代码随想录算法训练营Day40】01背包问题一维dp数组；二维dp数组（滚动数组）；416.分割等和子集

文章目录

❇️Day 41 第九章动态规划 part04
- ✴️今日任务
- ❇️01背包问题二维
- - 背包问题的区别
  - 暴力解法
  - 动规五部曲
- ❇️01背包问题一维
- - 二维转一维：滚动数组
  - 动规五部曲
- ❇️416. 分割等和子集
- - 随想录思路
  - 自己的思路
  - - 二维方法
    - 一维方法
  - 自己的代码
  - - 二维方法
    - 一维方法

❇️Day 41 第九章动态规划 part04

✴️今日任务

正式开始背包问题，背包问题还是挺难的，虽然大家可能看了很多背包问题模板代码，感觉挺简单，但基本理解的都不够深入。
如果是直接从来没听过背包问题，可以先看文字讲解慢慢了解这是干什么的。
如果做过背包类问题，可以先看视频，很多内容，是自己平时没有考虑到位的。背包问题，力扣上没有原题，大家先了解理论，今天就安排一道具体题目。

01背包问题，你该了解这些！
01背包问题，你该了解这些！滚动数组
416.分割等和子集

❇️01背包问题二维

视频讲解：https://www.bilibili.com/video/BV1cg411g7Y6
文章链接：https://programmercarl.com/%E8%83%8C%E5%8C%85%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%8001%E8%83%8C%E5%8C%85-1.html

背包问题的区别

0-1背包：n种物品，每种物品只有一个
完全背包：n种物品，每种物品有无限个
多重背包：n种物品，每种物品的个数各不相同

暴力解法

利用回溯列举出每一种方法

动规五部曲

dp数组的含义：dp[i][j]：[0,i]之间的物品任取，在容量为j时最大价值为dp[i][j]
递归公式：dp[i][j] = Math.max(dp[i - 1][j - weight[i]] + value[i], dp[i - 1][j]);
- 不放物品i：dp[i - 1][j]（也就是前面i-1个物品放不放的最大价值）
- 放物品i：dp[i - 1][j - weight[i]] + value[i]
初始化
1. 由递归公式得出dp[i][j]是由dp[i - 1][j]和dp[i - 1][j]推出来的（上方和左上角）
2. 所以需要初始化第一列和第一行，且具体情况具体分析
3. 第一列dp[i][j = 0]，容量为0价值自然为0；
4. 第一行dp[i = 0][j]，只能放物品0，01背包只能放一个，所以用value[0]初始化第一行，但要注意物品0的重量，j < weight[0]时dp[0][j] = 0
5. 其他地方不需要初始化，之后会被赋值更新
遍历顺序
1. 对于二维的01背包问题，两个for循环先遍历背包or先遍历物品都可以
2. 先遍历物品：从左到右从上到下一行一行遍历
3. 先遍历背包：从上到下从左到右一列一列遍历
4. 因为dp[i][j]取决于上方和左上方的数，所以这两种遍历方式都可以

❇️01背包问题一维

视频讲解：https://www.bilibili.com/video/BV1BU4y177kY
文章链接：https://programmercarl.com/%E8%83%8C%E5%8C%85%E7%90%86%E8%AE%BA%E5%9F%BA%E7%A1%8001%E8%83%8C%E5%8C%85-2.html

二维转一维：滚动数组

为什么二维可以转变为一维：

根据二维的递归公式：dp[i][j] = Math.max(dp[i - 1][j] - weight[i] + value[i], dp[i - 1][j]);
dp[i][j]是通过上一层dp[i - 1][]的数据得到的
想法是：将dp[i - 1][]的数据拷贝到下一层dp[i][]这样dp[i][j]就可以在自己层操作
相当于把矩阵压缩成了一行，数据是一个滚动的状态，所以也叫滚动数组

动规五部曲

dp数组的含义：dp[j]：容量为j的背包可以放的最大价值为dp[j]
递归公式：dp[j] = Math.max(dp[j], dp[j - weight[i]] + value[i]);
1. 不放物品i：dp[j]，原来是dp[i - 1][j]但上一层数据已经拷贝下来了所以是dp[j]
2. 放物品i：dp[j - weight[i]] + value[i]
初始化：dp[0] = 0;
遍历顺序：倒序遍历
1. 如果正序遍历取用前面的数值已经被覆盖掉了会影响后面数据的取值
2. 二维数组转化成一维数组的时候，是将上一层的值直接拷贝到当前层，但是从二维数组的计算中，我们可以发现计算当前值是需要利用上方和左边的值，从右向前遍历，我们是从右往左覆盖，这时候左边的值还可以用

❇️416. 分割等和子集

本题是 01背包的应用类题目
题目链接：https://leetcode.cn/problems/partition-equal-subset-sum/
视频讲解：https://www.bilibili.com/video/BV1rt4y1N7jE
文章链接：https://programmercarl.com/0416.%E5%88%86%E5%89%B2%E7%AD%89%E5%92%8C%E5%AD%90%E9%9B%86.html

随想录思路

分成两个元素和相等的子集，所以每个子集的和都是数组和的一半
转换成背包问题：看数组中的元素是否能装满容量为一半和的背包
1. nums[i]即是重量也是价值
2. 所以判断能否装满的条件dp[nums.length - 1][target] == target
因为数组中的元素只能用一次，所以是01背包问题

自己的思路

二维方法

dp数组的含义：dp[i][j]：[0,i]物品中任意放入容量为j的背包中的最大价值为dp[i][j]
1. i最大为nums.length - 1
2. j最大为nums元素总和的一半
递归公式：dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - nums[i]] + nums[i]);
初始化：dp[i][0] = 0; if(nums[0] <= j) dp[0][j] = nums[0]; else dp[0][j] = 0;
遍历顺序：都行
打印dp数组

一维方法

dp数组的含义：dp[j]：数组中数据任意放入子集，子集的最大和为dp[j]
1. j最大为nums元素总和的一半
递归公式：dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i]);
初始化：dp[0] = 0; if(nums[0] <= j) dp[j] = nums[0]; else dp[j] = 0;
遍历顺序：倒序遍历
打印dp数组

自己的代码

二维方法

class Solution {
    public boolean canPartition(int[] nums) {
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        //如果和为奇数直接返回false
        if(sum % 2 != 0) return false;
        int dp[][] = new int[nums.length][sum / 2 + 1];
        for (int j = 0; j <= sum / 2; j++) {
            if(nums[0] <= j) dp[0][j] = nums[0];
            else  dp[0][j] = 0;
        }
        for (int i = 0; i < nums.length; i++) {
            dp[i][0] = 0;
            //System.out.println(Arrays.toString(dp[i]));
        }
        for (int i = 1; i < nums.length; i++) {
            for (int j = 1; j <= sum / 2; j++) {
                if(j >= nums[i]) {
                    dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - nums[i]] + nums[i]);
                }else{
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }
        
        if(dp[nums.length - 1][sum / 2] == sum / 2){
            return true;
        }else{
            return false;
        }
    }
}

一维方法

踩坑点：
物品要从第二个开始，也就是i要从1开始

class Solution {
    public boolean canPartition(int[] nums) {
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
        }
        //如果和为奇数直接返回false
        if(sum % 2 != 0) return false;
        int dp[] = new int[sum / 2 + 1];
        dp[0] = 0;
        for (int j = 0; j <= sum / 2; j++) {
            if(nums[0] <= j)
                dp[j] = nums[0];
            else
                dp[j] = 0;
        }
        //System.out.println(Arrays.toString(dp));
        for (int i = 1; i < nums.length; i++) {
            for (int j = sum / 2; j >= 0; j--) {
                if(j >= nums[i])
                    dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i]);
            }
        }
        //System.out.println(Arrays.toString(dp));
        if(dp[sum / 2] == sum / 2)return true;
        else return false;
    }
}