力扣Day42（2.19）| 第八章 动态规划 （01背包理论基础 70. 爬楼梯 416. 分割等和子集）

理论一：01背包理论和实现

链接

视频链接：
文章链接：

视频总结

关键点

代码（二维dp数组）

思路一：

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) 
        
# 反思1：

文档总结

1. 文档和视频的思路分析非常经典

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

链接

视频链接：
文章链接：

视频总结

关键点

1. 初始化时，因为要比大小，而初始化的数据相当于上一轮的数据，且不能影响后续的递推运算，所以应该是非零里面最小的数，也就是零（有章法的！）
2. 倒序遍历是为了每个数组只被添加一次，通过举例就可以发现。而二维dp数组可以正序遍历，因为每层的数是由上一层的数推导出来的，两层是相互隔离的，而一维dp数组中，数据是重复使用的 ，只有倒序才层保证使用的是上一次的数据，而不是更新后的数据！（也就是正序的，使用的dp不是上一层的，是同一层的）
3. key：为何一维数组时，for循环的顺序不可变？（代码里有注释）
   

代码实战

思路一：

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

    # 先遍历物品, 再遍历背包容量
    # 理解ij的关键是：dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。因为一维数组的本
    for i in range(len(weight)):	#质还是二维遍历，只不过调用信息和存储信息的方式发生了变化，如果先按照背包容量的方向
        for j in range(bag_weight, weight[i] - 1, -1):	#来遍历，那么就会丢失上层的dp[j]信息，因此一维数组的for循环顺序不可变
            # 递归公式
            dp[j] = max(dp[j], dp[j - weight[i]] + value[i])

    print(dp)

test_1_wei_bag_problem()
        
# 反思1：

文档总结

1. 

题三：416. 分割等和子集

疑问：二维背包需要排序吗。一维背包无所谓顺序吗？不需要，出问题不在那个地方，而且从原理上也不需要

链接

题目链接：
视频链接：
文章链接：

视频总结

关键点

编程思路

Me：

1. 所有元素和为那个数的两倍
2. 和为奇数返回false

卡尔：

1. 和为偶数，则除以二，判断集合是否有几个数之和是它！画二叉树用回溯法，负责度为二的恩方
2. 若转化成背包问题：我们有集合里这么多个物品，每个物品体积为列表值，问是否能够装进容量为总和一半的背包里面
   

力扣实战

思路一：一维dp

 class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        if sum(nums)%2 == 1:
            return False
        else:
            target = sum(nums)//2   #只能是//向下整除，/的结果是浮点数，不可用于range里
            dp = [0]*(target+1)  # dp[i] 表示当背包重量为i时，最大价值是dp[i]
            for i in range(len(nums)):  # i是对物品更新,表示从下标为[0-i]的物品里任意取，
                k = nums[i]	#小于k的地方不会出现在for循环里，也就是保持上一轮的dp相当于讨论了要加的东西是否大于j
                for j in range(target,k-1,-1):  # j是对背包总重量 range(右,左-1，-1)从大往小遍历，包括右，不包括左-1 ，j只取了大于物品重量的地方！！相当于剪枝
                    dp[j] = max(dp[j],dp[j-nums[i]]+nums[i]) 
            return dp[target]==target	#背包容量是target且在所有物品里随便放时，获得的最大价值（最多为15）

       

        
# 反思1：

思路二：二维dp

 class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        if sum(nums)%2 == 1:
            return False
        else:
            
            target = sum(nums)//2   #只能是//向下整除，/的结果是浮点数，不可用于range里
            dp = [[0 for _ in range(target+1)] for _ in range(len(nums))]   # dp[i] 表示当背包重量为i时，最大价值是dp[i]
            # 初始 dp value
            for i in range(len(nums)):
                dp[i][0] = 0
            
            for j in range(1, target):
                if nums[0] <= j:
                    dp[0][j] = nums[0]
            for i in range(1,len(nums)):  # i是对物品更新,表示从下标为[0-i]的物品里任意取，
                k = nums[i]
                # dp[i][j] = max(dp[i-1][j],dp[i-1][j-w[i]+val[i])
                for j in range(1,target+1):  # j是对背包总重量 range(右,左-1，-1)从大往小遍历，包括右，不包括左-1 
                    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	#负一表示所有物品都考虑

       

文档总结

1. 疑问：为何二维的需要判断是否能够装进去，有个if判断语句，不加的时候还会报错，而一维的直接就选择大一点的那个，答案就是for循环，的第二个位置是nums[i]-1,就直接让所有的j剩余空间大于了物品的体积，而小于的保持不变，保持不变就是相当于保持上一轮的dp，相当于赋值了上一轮的dp！妙哇，这都分析出来了！！666