代码随想录算法训练营day41 | 01背包问题 二维、01背包问题 一维、416. 分割等和子集

背包问题的理论基础重中之重是01背包

01背包问题 二维

二维dp的01背包

1. 确定dp数组以及下标的含义：dp[i][j]表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少
2. 确定递推公式：dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i])
3. dp数组如何初始化：当j为0时，dp[i][0] = 0; 当i为0时，如果weight[0] > j, dp[0][j] = 0，否则dp[0][j] = value[0]
4. 确定遍历顺序：因为下一个状态是由左上边和上面得到的，所以从前往后遍历，可以先遍历物品，也可以先遍历背包重量
5. 举例推导dp数组：

def test_2_wei_bag_problem1(weight, value, bagweight):
    # 二维数组
    dp = [[0] * (bagweight + 1) for _ in range(len(weight))]

    # 初始化，因为数组在定义的时候已经初始化为0了，所以只需要把剩下不为0的重新初始化
    for j in range(weight[0], bagweight + 1):
        dp[0][j] = value[0]

    # weight数组的大小就是物品个数
    for i in range(1, len(weight)):  # 遍历物品
        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])

    return dp[len(weight) - 1][bagweight]

01背包问题 一维

一维dp数组（滚动数组）

之前使用二维数组的时候，当前的状态是由上面一层[i-1] 正上方和左上方来决定，因为我们可以压缩物品这层数组，则当前的状态可以由自身和左边来决定。

如果背包继续从左向右遍历，则会覆盖掉左边的数据，右边的使用的就不是上层的数据。并且由于背包需要从右向左遍历，如果先遍历背包的话，背包中只会有一个物品

1. 确定dp数组以及下标的含义：dp[j]表示容量为j的背包，价值最大是多少
2. 确定递推公式：dp[j] = max(dp[j], dp[j - weight[i]] + value[i])
3. dp数组如何初始化：dp[0] = 0，假设物品价值都是大于0的，所以dp数组初始化的时候，都初始为0
4. 确定遍历顺序：先遍历物品，再遍历背包重量，背包重量需要从后向前遍历
5. 举例推导dp数组：

def test_1_wei_bag_problem(weight, value, bagWeight):
    # 初始化
    dp = [0] * (bagWeight + 1)
    for i in range(len(weight)):  # 遍历物品
        for j in range(bagWeight, weight[i] - 1, -1):  # 遍历背包容量
            dp[j] = max(dp[j], dp[j - weight[i]] + value[i])

    return dp[bagWeight]

416. 分割等和子集

01背包的应用题

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

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

动态规划五部曲

1. 确定dp数组以及下标的含义：dp[j]表示容量为j的背包，价值最大是多少。背包总容量是j，放进物品后，背的最大重量为dp[j]
2. 确定递推公式：dp[j] = max(dp[j], dp[j - nums[i]] + nums[i])
3. dp数组如何初始化：本题题目中只包含正整数的非空数组，所以非0下标的元素初始化为0就可以了
4. 确定遍历顺序：先遍历物品，再遍历背包重量，背包重量需要从后向前遍历
5. 举例推导dp数组：

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        _sum = sum(nums)
        if _sum % 2 == 1:
            return False
        target = _sum // 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])

        if dp[target] == target:
            return True
        return False