代码随想录算法训练营Day30 | 01背包问题（卡码网46. 携带研究材料）、Leetcode416.分割等和子集

一、01背包问题

相关题目：卡码网46. 携带研究材料

文档讲解：01背包问题（二维）、01背包问题（一维）

视频讲解：01背包问题（二维）、01背包问题（一维）

1. 01背包问题种类

2. 01背包问题

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

例：背包最大重量为4，物品重量及价值如下：

	重量	价值
物品0	1	15
物品1	3	20
物品2	4	30

思路（二维 dp 数组） ：
- 动规五部曲（利用二维 dp 数组） ：
  - 确定 dp 数组以及下标的含义 ：需要两个维度 i ，j 分别表示物品和背包容量。dp[i][j] 表示从下标为 [0-i] 的物品里任意取，放进容量为 j 的背包，价值总和最大是多少。
    
    把物品 0 与物品 1 放入背包的情况：
  - 确定递推公式：以 dp[1][4] 的状态为例，求取 dp[1][4] 有两种情况：
    - 不放物品1：背包的价值应该是 dp[0][4] ，即容量为 4 的背包，只放物品 0 的情况。
    - 放物品1：背包要先留出物品 1 的容量，目前容量是 4，物品1 的重量为 3，此时背包剩下容量为 1，而容量为 1 最大价值是 dp[0][1]，所以放物品1 的情况 = dp[0][1] + 物品1 的价值。
      
      以上过程，可以抽象化如下：
    - 不放物品 i：背包容量为 j，里面不放物品i的最大价值是 dp[i - 1][j]。
    - 放物品 i：背包空出物品 i 的容量后，背包容量为 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] 即：存放编号 0 的物品的时候，各个容量的背包所能存放的最大价值，这分两种情况：
    - 当 j < weight[0] 的时候，dp[0][j] 应该是 0，因为背包容量比编号 0 的物品重量还小。
    - 当 j >= weight[0]时，dp[0][j] 应该是value[0]，因为背包容量放足够放编号 0 物品。
    此时 dp 数组初始化情况如图所示：
    
    最后，从递归公式可以看出 dp[i][j] 是由左上方数值推导出来的，则其他下标初始是什么数值都可以，因为都会被覆盖。不过一开始就统一把 dp 数组统一初始为 0更方便一些。所以 dp 数组初始化情况如图：
  - 确定遍历顺序 ：有两个遍历的维度：物品与背包重量，先遍历物品或先遍历背包重量都可以！
    - 先遍历物品，再遍历背包的过程如图所示：
    - 先遍历背包，再遍历物品的过程如图所示：
  - 举例推导 dp 数组 ：
动态规划（二维 dp 数组）

python 复制代码

n, bagweight = map(int, input().split())

weight = list(map(int, input().split()))
value = list(map(int, input().split()))

dp = [[0] * (bagweight + 1) for _ in range(n)]

for j in range(weight[0], bagweight + 1):
    dp[0][j] = value[0]

for i in range(1, n):
    for j in range(bagweight + 1):
        if j < weight[i]:
            dp[i][j] = dp[i - 1][j]
        else:
            dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i])

print(dp[n - 1][bagweight])

思路（一维 dp 数组） ：在前述利用二维 dp 数组的解法中，递推公式为 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 数组） ：
  - 确定 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 的价值。此时 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[0] 应该是 0，因为背包容量为 0 所背的物品的最大价值就是 0。而由递推公式可以发现 dp 数组在推导的时候一定是取价值最大的数，如果题目给的价值都是正整数则非 0 下标都初始化为 0 即可。这样才能让 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 - weight[0]] + value[0] = 15 （dp 数组已经都初始化为0），dp[1] = dp[1 - weight[0]] + value[0] = 15，每次取得状态不会和之前取得状态重合，每种物品就只取一次。
    而二维 dp 数组遍历的时候不用倒序是因为 dp[i][j] 都是通过上一层即 dp[i - 1][j] 计算而来，本层的 dp[i][j] 并不会被覆盖！不同于二维 dp 数组，一维 dp 数组需先遍历物品嵌套遍历背包容量，不可以先遍历背包容量嵌套遍历物品！ 因为一维 dp 的写法，背包容量要倒序遍历，如果遍历背包容量放在上一层，那么每个 dp[j] 就只会放入一个物品，即：背包里只放入了一个物品。
  - 举例推导 dp 数组 ：一维 dp，分别用物品0，物品1，物品2 来遍历背包，最终得到结果如下：
动态规划（一维 dp 数组）

python 复制代码

n, bagweight = map(int, input().split())
weight = list(map(int, input().split()))
value = list(map(int, input().split()))

dp = [0] * (bagweight + 1)  # 创建一个动态规划数组dp，初始值为0

dp[0] = 0  # 初始化dp[0] = 0,背包容量为0，价值最大为0

for i in range(n):  # 应该先遍历物品，如果遍历背包容量放在上一层，那么每个dp[j]就只会放入一个物品
    for j in range(bagweight, weight[i]-1, -1):  # 倒序遍历背包容量是为了保证物品i只被放入一次
        dp[j] = max(dp[j], dp[j - weight[i]] + value[i])

print(dp[bagweight])

二、分割等和子集

相关题目：Leetcode416

文档讲解：Leetcode416

视频讲解：Leetcode416

1. Leetcode416.分割等和子集

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

提示：

1 <= nums.length <= 200

1 <= nums[i] <= 100

思路：
- 题目是要找是否可以将这个数组分割成两个子集，使得两个子集的元素和相等，那么只要找到集合里能够出现 sum / 2 的子集总和，就是可以分割成两个相同元素和子集。可以利用 01背包问题，本题要求集合里能否出现总和为 sum / 2 的子集，即有一个只能装重量为 sum / 2 的背包，商品为数字，这些数字能不能把这个背包装满。 如果每一件商品是数字的话，重量等于价值，本题可以转化为"对于承载重量为 sum / 2 的背包，所能装的价值最大是多少"。如果最大价值是 sum / 2，说明正好被商品装满了。
- 动规五部曲 ：
  - 确定 dp 数组以及下标的含义：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 数组如何初始化：首先 dp[0] 一定是 0，如果题目给的价值都是正整数那么非 0 下标都初始化为 0 即可，如果题目给的价值有负数，那么非 0 下标就要初始化为负无穷。这样才能让 dp 数组在递推的过程中取得最大的价值，而不是被初始值覆盖了。
  - 确定遍历顺序：如果使用一维 dp 数组，物品遍历的 for 循环放在外层，遍历背包的 for 循环放在内层，且内层 for 循环倒序遍历！
  - 举例推导 dp 数组 ：以输入 [1,5,11,5] 为例，如图：
动态规划（卡哥）

python 复制代码

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

        # dp[i]中的i表示背包内总和
        # 题目中说：每个数组中的元素不会超过 100，数组的大小不会超过 200
        # 总和不会大于20000，背包最大只需要其中一半，所以10001大小就可以了
        dp = [0] * 10001
        for num in nums:
            _sum += num
        # 也可以使用内置函数一步求和
        # _sum = sum(nums)
        if _sum % 2 == 1:
            return False
        target = _sum // 2

        # 开始 0-1背包
        for num in nums:
            for j in range(target, num - 1, -1):  # 每一个元素一定是不可重复放入，所以从大到小遍历
                dp[j] = max(dp[j], dp[j - num] + num)

        # 集合中的元素正好可以凑成总和target
        if dp[target] == target:
            return True
        return False

###简化
class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        if sum(nums) % 2 != 0:
            return False
        target = sum(nums) // 2
        dp = [0] * (target + 1)
        for num in nums:
            for j in range(target, num-1, -1):
                dp[j] = max(dp[j], dp[j-num] + num)
        return dp[-1] == target

二维 dp

python 复制代码

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

        if total_sum % 2 != 0:
            return False

        target_sum = total_sum // 2
        dp = [[False] * (target_sum + 1) for _ in range(len(nums) + 1)]

        # 初始化第一行（空子集可以得到和为0）
        for i in range(len(nums) + 1):
            dp[i][0] = True

        for i in range(1, len(nums) + 1):
            for j in range(1, target_sum + 1):
                if j < nums[i - 1]:
                    # 当前数字大于目标和时，无法使用该数字
                    dp[i][j] = dp[i - 1][j]
                else:
                    # 当前数字小于等于目标和时，可以选择使用或不使用该数字
                    dp[i][j] = dp[i - 1][j] or dp[i - 1][j - nums[i - 1]]

        return dp[len(nums)][target_sum]

一维 dp

python 复制代码

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

        total_sum = sum(nums)

        if total_sum % 2 != 0:
            return False

        target_sum = total_sum // 2
        dp = [False] * (target_sum + 1)
        dp[0] = True

        for num in nums:
            # 从target_sum逆序迭代到num，步长为-1
            for i in range(target_sum, num - 1, -1):
                dp[i] = dp[i] or dp[i - num]
        return dp[target_sum]