【动态规划】01背包理论基础、01背包理论基础（滚动数组）、416. 分割等和子集

lx1234lj

已于 2023-10-07 19:50:25 修改

阅读量45

点赞数

分类专栏：算法文章标签：动态规划算法

于 2023-10-06 20:33:11 首次发布

本文链接：https://blog.csdn.net/lx1234lj/article/details/133618392

版权

算法专栏收录该内容

50 篇文章 0 订阅

订阅专栏

提示：努力生活，开心、快乐的一天

文章目录

01背包理论基础
01背包理论基础（滚动数组）
416. 分割等和子集
🎈今日心得

01背包理论基础

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

💡解题思路

动规五部曲：

确定dp数组以及下标的含义：dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。
确定递推公式：根据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]]推出，dp[i - 1][j - weight[i]] 为背包容量为j - weight[i]的时候不放物品i的最大价值，那么dp[i - 1][j - weight[i]] + value[i] （物品i的价值），就是背包放物品i得到的最大价值
递归公式： dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
dp数组如何初始化：首先从dp[i][j]的定义出发，如果背包容量j为0的话，即dp[i][0]，无论是选取哪些物品，背包价值总和一定为0。dp[0][j]，即：i为0，存放编号0的物品的时候，各个容量的背包所能存放的最大价值。那么很明显当 j < weight[0]的时候，dp[0][j] 应该是 0，因为背包容量比编号0的物品重量还小。当j >= weight[0]时，dp[0][j] 应该是value[0]，因为背包容量放足够放编号0物品。其他下标都应该初始化为0
确定遍历顺序：有两个遍历的维度：物品与背包重量，先遍历哪个都可以
举例推导dp数组：按照递推公式推导一下做推导，如果发现结果不对，就把dp数组打印出来

🤔遇到的问题

整体都不好想，初始化，、推到公式，还有比那里顺序都不好想

💻代码实现

动态规划

function testWeightBagProblem (weight, value, size) {
    // 定义 dp 数组
    const len = weight.length,
          dp = Array(len).fill().map(() => Array(size + 1).fill(0));

    // 初始化
    for(let j = weight[0]; j <= size; j++) {
        dp[0][j] = value[0];
    }

    // weight 数组的长度len 就是物品个数
    for(let i = 1; i < len; i++) { // 遍历物品
        for(let j = 0; j <= size; j++) { // 遍历背包容量
            if(j < weight[i]) dp[i][j] = dp[i - 1][j];
            else dp[i][j] = Math.max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
        }
    }

    console.table(dp)

    return dp[len - 1][size];
}

🎯题目总结

1.背包问题很难，但依旧按照动态规划的五部曲进行分析，一步步来

01背包理论基础（滚动数组）

leecode暂无题目
题意与上面一样，只是用一维数组进行实现

💡解题思路

在使用二维数组的时候，递推公式：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i]);
其实可以发现如果把dp[i - 1]那一层拷贝到dp[i]上，表达式完全可以是：dp[i][j] = max(dp[i][j], dp[i][j - weight[i]] + value[i]);
与其把dp[i - 1]这一层拷贝到dp[i]上，不如只用一个一维数组了，只用dp[j]
这就是滚动数组的由来，需要满足的条件是上一层可以重复利用，直接拷贝到当前层。
dp[i][j]里的i和j表达的是什么了，i是物品，j是背包容量。
dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。
动规五部曲：

确定dp数组以及下标的含义：dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]。
确定递推公式：dp[j]可以通过dp[j - weight[i]]推导出来，dp[j - weight[i]]表示容量为j - weight[i]的背包所背的最大价值。
dp[j - weight[i]] + value[i] 表示容量为 j - 物品i重量的背包加上物品i的价值。（也就是容量为j的背包，放入物品i了之后的价值即：dp[j]）
此时dp[j]有两个选择，一个是取自己dp[j] 相当于二维dp数组中的dp[i-1][j]，即不放物品i，一个是取dp[j - weight[i]] + value[i]，即放物品i，指定是取最大的，毕竟是求最大价值，
递归公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
dp数组如何初始化：dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]，那么dp[0]就应该是0，因为背包容量为0所背的物品的最大价值就是0。其他下标都应该初始化为0
确定遍历顺序：倒序遍历的原因是，本质上还是一个对二维数组的遍历，并且右下角的值依赖上一层左上角的值，因此需要保证左边的值仍然是上一层的，从右向左覆盖。
举例推导dp数组：按照递推公式推导一下做推导，如果发现结果不对，就把dp数组打印出来

🤔遇到的问题

递归公式的变换及遍历顺序的确定

💻代码实现

动态规划

function testWeightBagProblem(wight, value, size) {
  const len = wight.length, 
    dp = Array(size + 1).fill(0);
  for(let i = 1; i <= len; i++) {
    for(let j = size; j >= wight[i - 1]; j--) {
      dp[j] = Math.max(dp[j], value[i - 1] + dp[j - wight[i - 1]]);
    }
  }
  return dp[size];
}

🎯题目总结

将二维数组变化为一维数组，但是其本质的遍历还是二维数组的遍历

416. 分割等和子集

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

💡解题思路

01背包问题的具体应用，只有确定了如下四点，才能把01背包问题套到本题上来。
- 背包的体积为sum / 2
- 背包要放入的商品（集合里的元素）重量为元素的数值，价值也为元素的数值
- 背包如果正好装满，说明找到了总和为 sum / 2 的子集。
- 背包中每一个元素是不可重复放入。
动规五部曲：

确定dp数组以及下标的含义：dp[j]表示背包总容量（所能装的总重量）是j，放进物品后，背的最大重量为dp[j]。
确定递推公式：01背包的递推公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
本题，相当于背包里放入数值，那么物品i的重量是nums[i]，其价值也是nums[i]。
所以递推公式：dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
dp数组如何初始化：从dp[j]的定义来看，首先dp[0]一定是0。本题题目中只包含正整数的非空数组，所以非0下标的元素初始化为0就可以了。
确定遍历顺序：如果使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历！
举例推导dp数组：dp[j]的数值一定是小于等于j的。如果dp[j] == j 说明，集合中的子集总和正好可以凑成总和j

🤔遇到的问题

最终的返回格式与背包问题不一样
题目中物品是nums[i]，重量是nums[i]，价值也是nums[i]，背包体积是sum/2。

💻代码实现

动态规划

var canPartition = function(nums) {
    let sum = nums.reduce((a, b) => a + b);
    if (sum & 1) return false
    //背包的最大体积
    let dp = new Array(sum / 2 + 1).fill(0)
    for (let i = 0; i < nums.length; i++) {//遍历物品（数组）
        for (let j = sum / 2; j >= nums[i]; j--){//遍历背包（子集的和）-倒序
            //状态转移公式
            dp[j] = Math.max(dp[j], dp[j - nums[i]] + nums[i])
            if (dp[j] === sum / 2) {
                return true
            }
        }
    }
    return dp[sum/2] === sum/2
};