代码随想录训练营 Day35打卡动态规划 part03 01背包理论基础 416. 分割等和子集

那一抹阳光多灿烂

于 2024-08-20 08:49:49 发布

阅读量530

点赞数 14

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

本文链接：https://blog.csdn.net/qq_42952637/article/details/141315139

版权

力扣同时被 2 个专栏收录

23 篇文章 0 订阅

订阅专栏

动态规划

3 篇文章 0 订阅

订阅专栏

代码随想录训练营 Day35打卡动态规划 part03

一、01背包理论基础

二维dp数组

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

在这里插入图片描述
我们需要使用二维数组，为什么呢？

因为有两个维度需要表示，分别是：物品和背包容量

如图，二维数组为 dp[i][j]。

在这里插入图片描述

dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。
对于递推公式，首先我们要明确有哪些方向可以推导出 dp[i][j]。

这里我们dp[1][4]的状态来举例：

绝对 dp[1][4]，就是放物品1 ，还是不放物品1。

如果不放物品1，那么背包的价值应该是 dp[0][4] 即容量为4的背包，只放物品0的情况。

推导方向如图：
在这里插入图片描述
如果放物品1，那么背包要先留出物品1的容量，目前容量是4，物品1 需要重量为3，此时背包剩下容量为1。

容量为1，只考虑放物品0 的最大价值是 dp[0][1]，这个值我们之前就计算过。

所以放物品1 的情况 = dp[0][1] + 物品1 的重量，推导方向如图：
在这里插入图片描述
以上过程，抽象化如下：

不放物品i：由dp[i - 1][j]推出，即背包容量为j，里面不放物品i的最大价值，此时dp[i][j]就是dp[i - 1][j]。

放物品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 - 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[i][j]中i的维度去掉了。

这里大家发现和二维dp的写法中，遍历背包的顺序是不一样的！

二维dp遍历的时候，背包容量是从小到大，而一维dp遍历的时候，背包是从大到小。

为什么呢？

**倒序遍历是为了保证物品i只被放入一次！**但如果一旦正序遍历了，那么物品0就会被重复加入多次！

举一个例子：物品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]就已经是30了，意味着物品0，被放入了两次，所以不能正序遍历。

为什么 倒序遍历 ，就可以 保证物品只放入一次 呢？

倒序就是先算dp[2]

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

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

所以从后往前循环，每次取得状态不会和之前取得状态重合，这样每种物品就只取一次了。

二、力扣416. 分割等和子集

给你一个 只包含正整数 的非空数组 nums 。请你判断是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。
示例：
输入：nums = [1,5,11,5]
输出：true
解释：数组可以分割成 [1, 5, 5] 和 [11] 。

要明确本题中我们要使用的是01背包，因为元素我们只能用一次。

只有确定了如下四点，才能把01背包问题套到本题上来。

背包的体积为sum / 2
背包要放入的商品（集合里的元素）重量为元素的数值，价值也为元素的数值
背包如果正好装满，说明找到了总和为 sum / 2 的子集。
背包中每一个元素是不可重复放入

dp[j]表示背包总容量（所能装的总重量）是j，放进物品后，背的最大重量为dp[j]。

那么如果背包容量为target， dp[target]就是装满背包之后的重量，所以当 dp[target] == target 的时候，背包就装满了。

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[j] == j 说明，集合中的子集总和正好可以凑成总和j，理解这一点很重要。

在这里插入图片描述
最后dp[11] == 11，说明可以将这个数组分割成两个子集，使得两个子集的元素和相等。

代码实现

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        _sum = 0

        # dp[i] 表示背包容量为 i 时，背包能够达到的最大重量
        # 题目中说：每个数组中的元素不会超过 100，数组的大小不会超过 200
        # 因此数组元素的总和不会大于 20000，背包最大只需要其中一半的容量，所以初始化 dp 数组的大小为 10001
        dp = [0] * 10001

        # 计算数组元素的总和
        for num in nums:
            _sum += num
        # 也可以使用内置函数一步求和
        # _sum = sum(nums)

        # 如果总和是奇数，那么不可能分割成两个和相等的子集，直接返回 False
        if _sum % 2 == 1:
            return False
        
        # 目标是找到一个子集，使得该子集的和等于总和的一半
        target = _sum // 2

        # 开始 0-1 背包问题的求解
        for num in nums:
            # 从后向前遍历 dp 数组，这是为了保证每个元素只能使用一次
            for j in range(target, num - 1, -1):
                # 状态转移方程：dp[j] 表示容量为 j 的背包，最大可以放的重量
                # 通过选择当前元素 num，我们可以得到新的状态 dp[j] = max(dp[j], dp[j - num] + num)
                dp[j] = max(dp[j], dp[j - num] + num)

        # 如果 dp[target] == target，说明我们可以找出一个子集，其和正好等于 target
        if dp[target] == target:
            return True
        # 否则返回 False
        return False