代码随想录算法训练营第四十二天

背包问题

解析视频：1，2
解析

0-1背包

n种物品，每种物品只有一个。

完全背包

n种物品，每种物品有无限个。

多重背包

n种物品，每种物品的个数不各相同。

0-1背包题目

背包最大重量为4。

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

暴力解法

每样东西取或者不取，用回溯来做，要找到最大值，那就要遍历完。

二维dp

dp[i][j] = 编号在[0,i]的物品任取放进容量为j的背包里的最大价值。
dp[i][j]的状态取决于放不放物品i

• 不放物品i，dp[i-1][j] 没放i的时候（用[0,i-1]的物品装满背包）的最大价值。
• 放了物品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	0	1	2	3	4
0	0	0	0	0	0
1	0
2	0

初始化：

• 背包容量为0的话啥也不能装，所以dp[i][0]全是0
• 只有物品0能装的，所以
  dp[0][j]=value[0] if weight[0] <= j else 0
  其他地方的初始化随意，没有影响

遍历顺序：

• 从推到公式来看，dp[i][j] 是由dp[i-1][j]（正上方的元素）和dp[i-1][j-weight[i]]（左斜上方的元素）得到的，所以遍历顺序应该是从小到大
• 对这道题来说，先遍历是谁都一样。

def test_2_wei_bag_problem1(bag_size, weight, value) -> int:
	rows, cols = len(weight), bag_size + 1
	dp = [[0 for _ in range(cols)] for _ in range(rows)]

	# 初始化dp数组.
	for i in range(rows):
		dp[i][0] = 0
	first_item_weight, first_item_value = weight[0], value[0]
	for j in range(1, cols):
		if first_item_weight <= j:
			dp[0][j] = first_item_value

	# 更新dp数组: 先遍历物品, 再遍历背包.
	for i in range(1, len(weight)):
		cur_weight, cur_val = weight[i], value[i]
		for j in range(1, cols):
			if cur_weight > j: # 说明背包装不下当前物品.
				dp[i][j] = dp[i - 1][j] # 所以不装当前物品.
			else:
				# 定义dp数组: dp[i][j] 前i个物品里，放进容量为j的背包，价值总和最大是多少。
				dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - cur_weight]+ cur_val)

	print(dp)

if __name__ == "__main__":
	bag_size = 4
	weight = [1, 3, 4]
	value = [15, 20, 30]
	test_2_wei_bag_problem1(bag_size, weight, value)

一维dp

dp[i][j] = max(dp[i-1][j], dp[i-1][j-weight[i]]+value[i])
把dp[i-1][j]一整层拷贝到i层，形成滚动数组，直接进行计算。
dp[j] = 容量为j的背包所能装的最大价值

• 不放物品i，dp[j]（上一层拷贝下来的，所以就是他自己）
• 放物品i，dp[j-weight[i]]+value[i]

dp[j] = max(dp[j],dp[j-weight[i]]+value[i])

	0	1	2	3	4
dp	0	0	0	0	0

初始化：

• 容量都是0了，dp[0]一定是0
• 别的值，由于要和自己max，所以初始化就给0

遍历顺序：
因为我们要用上一层i-1覆盖这一层i的dp，所以i（物品）的遍历是第一层且顺序。
j的遍历顺序不能是顺序，因为dp[j-weight[i]]代表的是容量为j-weight[i]的背包所能装的最大价值，如果是正序，也就是说dp[j-weight[i]]也是有可能已经算上物品i了的，在这种情况下0-1问题没法再加一次了。所以j得是倒序的用上一层的dp来取max决定放不放物品i。

def test_1_wei_bag_problem():
    weight = [1, 3, 4]
    value = [15, 20, 30]
    bag_weight = 4
    # 初始化: 全为0
    dp = [0] * (bag_weight + 1)

    # 先遍历物品, 再遍历背包容量
    for i in range(len(weight)):
        for j in range(bag_weight, weight[i] - 1, -1):
            # 递归公式
            dp[j] = max(dp[j], dp[j - weight[i]] + value[i])

    print(dp)

test_1_wei_bag_problem()

个人觉得因为是倒着的，如果走到最后一层，先出现的是最后一个j也就是最终答案，其实可以直接break掉了，也不用往下了，前面的j我们并不感兴趣。碰到类似的问题可以求证一下。

416. 分割等和子集

题目链接：添加链接描述
这道题要转换成求集合里能否出现总和为 sum / 2 的子集，就比较好继续做。
确定几点：

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

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        #集合里能否出现总和为 sum / 2 的子集。
        #dp[i][j] = 背包可以放总和为i的元素的前提下在[0,i]任选元素能放的最大重量。
        if sum(nums) % 2 == 1: return False
        target = sum(nums)//2
        dp = [[0]*(target + 1) for _ in range(len(nums))]
        for j in range(target + 1):
            if nums[0] <= j:
                dp[0][j] = nums[0]
        
        
        for i in range(len(nums)):
            for j in range(1,target+1):
                #不放nums[i], dp[i-1][j]
                #放nums[i], dp[i-1][j-nums[i]]+nums[i]
                if nums[i] > j:
                    dp[i][j] = dp[i-1][j]
                else:
                    dp[i][j] = max(dp[i-1][j],dp[i-1][j-nums[i]]+nums[i])
        
        return dp[-1][target] == target

一维

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        #集合里能否出现总和为 sum / 2 的子集。
        #dp[i][j] = 背包可以放总和为i的元素的前提下在[0,i]任选元素能放的最大重量。
        if sum(nums) % 2 == 1: return False
        target = sum(nums)//2
        dp = [0] * (target + 1)
        for i in range(len(nums)):
            for j in range(target, nums[i] - 1, -1):
                dp[j] = max(dp[j], dp[j - nums[i]] + nums[i])
        return target == dp[target]