代码随想录算法训练营第三十五天 | 0-1背包问题二维、0-1背包问题一维、416. 分割等和子集

Cedric7

已于 2024-08-05 20:27:15 修改

阅读量269

点赞数 3

分类专栏：代码随想录算法训练营文章标签：算法数据结构

于 2024-08-04 22:50:52 首次发布

本文链接：https://blog.csdn.net/weixin_43581681/article/details/140913639

版权

代码随想录算法训练营专栏收录该内容

54 篇文章 0 订阅

订阅专栏

一、0-1背包问题二维

题目链接：46. 携带研究材料（第六期模拟笔试） (kamacoder.com)
文章讲解：代码随想录 (programmercarl.com)——0-1背包问题二维
视频讲解：带你学透0-1背包问题！| 关于背包问题，你不清楚的地方，这里都讲了！| 动态规划经典问题 | 数据结构与算法_哔哩哔哩_bilibili

背包问题概述：
0-1背包：n种物品，每种物品只有一个；
完全背包：n种物品，每种物品无限个；
多重背包：n种物品，每种物品个数各不相同。

动态规划五部曲：
1. 确定 dp 数组及下标含义：dp[ i ][ j ] 表示下标 [ 0, i ] 的物品任取放进容量为 j 的背包。
2. 确定递推公式：
不放 i 最大价值：dp[ i - 1 ][ j ]
放 i 最大价值：dp[ i - 1 ][ j - wright[ i ]]（不放 i 同时减去 i 的容量之后的最大价值） + value( i )
递推公式： dp [ i ][ j ] = max(dp[ i - 1 ][ j ], dp[ i - 1 ][ j - wright[ i ]] + value( i ))，即取不放 i 时的最大价值与放了 i 之后的最大价值，因为 dp[ i - 1 ][ j ] 已经是前 i -1 物品最优解了。
3. 确定dp数组如何初始化：行代表固定不同物品，列代表固定背包容量，初始化第一行和第一列，第一列全部初始化为0，第一行根据题目描述，其余元素初始化任意值均可。
4. 确定遍历顺序：对于二维数组实现0-1背包，先遍历物品还是先遍历背包均可。
5. 举例推导dp数组。

def two_D_beibao(weight, value, bagweight):
    # 创建一个二维数组存储结果
    dp = [[0] * (bagweight + 1) for _ in range(len(weight))]
    
    #  初始化，只需要改变第一行的值
    for j in range(weight[0], bagweight + 1):
        dp[0][j] = value[0]
        
    # 先遍历物品
    for i in range(1, len(weight)):
        # 再遍历背包
        for j in range(bagweight + 1):
            # 如果当前背包容量不能放下物品 i ，那么 i - 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]
    
    
if __name__ == "__main__":
    
    weight = [2, 2, 3, 1, 5, 2]
    value = [2, 3, 1, 5, 4, 3]
    bagweight = 1
    
    result = two_D_beibao(weight, value, bagweight)
    
    print(result)

二、0-1背包问题一维

题目链接：46. 携带研究材料（第六期模拟笔试） (kamacoder.com)
文章讲解：代码随想录 (programmercarl.com)——0-1背包问题一维
视频讲解：带你学透01背包问题（滚动数组篇） | 从此对背包问题不再迷茫！_哔哩哔哩_bilibili

思路：二维背包问题递推公式中都是与 i - 1 有关，可以将 i - 1 层数据拷贝到第 i 层，降为一维 dp 数组。

动态规划五部曲：
1. 确定 dp 数组及下标含义：dp[ j ] 表示容量为 j 的背包所能装的最大价值
2. 确定递推公式：dp[ j ] = max( dp[ j ], dp[ j - weight[ i ]] + value[ i ] )
3. 确定dp数组如何初始化：dp[ 0 ] = 0，非0下标在后续递推过程中会被覆盖掉，因此初始化为最小的非负数即可，即全为0
4. 确定遍历顺序：第二层只能倒叙遍历，如果正序遍历则会添加多次物品；只能先遍历物品再遍历背包，因为把一个二维矩阵压缩为一个一维向量，相当于对上一层进行复用
# 遍历物品
for i in range(物品数量):
# 遍历背包，倒序遍历，保证每个物品只被添加过一次
for j in range(bagweight, weight[ i ] - 1, -1):
递推公式
5. 举例推导dp数组。

def one_D_beibao(weight, value, bagweight):
    # 创建一个二维数组存储结果，并初始化所有值为0
    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. 分割等和子集

题目链接：416. 分割等和子集 - 力扣（LeetCode）
文章讲解：代码随想录 (programmercarl.com)——416. 分割等和子集
视频讲解：动态规划之背包问题，这个包能装满吗？| LeetCode：416.分割等和子集_哔哩哔哩_bilibili

思路：用背包的思路寻找哪些元素可以装满容量为 $\frac{sum}{2}$ 的背包。

动态规划五部曲：
1. 确定 dp 数组及下标含义：dp[ j ] 表示容量为 j 的背包所背的最大价值
2. 确定递推公式：dp[ j ] = max( dp[ j ], dp[ j - weight[ i ]] + value[ i ] )，其中 weight 和 value 相同，所以 dp[ j ] = max( dp[ j ], dp[ j - nums[ i ]] + nums[ i ] )
3. 确定dp数组如何初始化：dp[ 0 ] = 0，其它防止覆盖都初始化成非负整数的最小值，即0
4. 确定遍历顺序：
# 遍历物品
for i in range(len(nums)):
# 遍历背包
for j in range(target, nums[ i ] - 1, -1):
递推公式
5. 举例推导dp数组。

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        # 创建dp数组，并全部初始化为0
        dp = [0] * 10001

        # 先判断如果没有之和不能被2整除，则直接False
        if sum(nums) % 2 != 0 :
            return False

        target = sum(nums) // 2

        # 先遍历物品
        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])

        # 判断集合中元素是否可以组成target
        if dp[target] == target:
            return True
        return False