LeetCode：动态规划中的0-1背包问题【快来直接套模板啦】

奋斗的西瓜瓜

已于 2022-11-01 09:07:38 修改

阅读量1.9k

点赞数 4

分类专栏： # LeetCode 文章标签：动态规划 leetcode 背包问题

于 2022-07-13 19:58:16 首次发布

本文链接：https://blog.csdn.net/qq_37085158/article/details/125771372

版权

LeetCode 专栏收录该内容

18 篇文章 18 订阅

订阅专栏

PS. 0-1背包问题无疑是动态规划题目里面的非常经典的一类题目了，下面给出这类题目的一种解题模板。本文是参考代码随想录做的一些笔记，完整版本请戳链接。

标准0-1背包问题

二维数组求解

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

每一件物品其实只有两个状态，取或者不取，所以可以使用回溯法搜索出所有的情况，那么时间复杂度就是 $o(2^n)$ ，这里的 $n$ 表示物品数量。所以暴力的解法是指数级别的时间复杂度，所以才需要动态规划的解法来进行优化！

举个例子：背包最大重量为4。物品为：

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

问背包能背的物品最大价值是多少？

dp[i][j]表示从下标为[0-i]的物品里任意取，放进容量为j的背包的最大价值总和 。

递推公式：有两个方向推出来dp[i][j]：

不放物品i：由dp[i - 1][j]推出，即背包容量为j，里面不放物品i的最大价值，此时dp[i][j]就是dp[i - 1][j]。（其实就是当物品i的重量大于背包j的重量时，物品i无法放进背包中，所以被背包内的价值依然和前面相同。)
放物品i：由dp[i - 1][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[i][j]的定义出发，如果背包容量j为0的话，即dp[i][0]，无论是选取哪些物品，背包价值总和一定为0。
从状态转移方程可以看出i是由i-1推导出来，那么i为0的时候就一定要初始化。dp[0][j]，即：i为0，存放编号0的物品的时候，各个容量的背包所能存放的最大价值。那么很明显当 j < weight[0]的时候，dp[0][j]应该是 0，因为背包容量比编号0的物品重量还小。当j >= weight[0]时，dp[0][j]应该是value[0]，因为背包容量放足够放编号0物品。

初始化代码：

for i in range(rows):
    dp[i][0] = 0
    
for i in range(1, cols):
    if i >= weight[0]:
         dp[0][i] = value[0]

这个问题有两个遍历的维度：物品与背包重量。那么，先遍历物品还是先遍历背包重量呢？其实都可以！！

先遍历物品，然后遍历背包重量：

for i in range(1, len(weight)):
    for j in range(1, bag_size + 1):
        if weight[i] > j:
            dp[i][j] = dp[i - 1][j]
        else:
            dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weight[i]] + value[i])

先遍历背包，再遍历物品：

for i in range(1, bag_size + 1):
    for j in range(1, len(weight)):
        if weight[j] > i:
            dp[j][i] = dp[j - 1][i]
        else:
            dp[j][i] = max(dp[j - 1][i], dp[j - 1][i - weight[j]] + value[j])

完整代码如下：

# 背包最大重量为4。物品为：
#            重量	价值
#       物品0	1	15
#       物品1	3	20
#       物品2	4	30
# 问背包能背的物品最大价值是多少？

"""
    二维数组实现
        dp[i][j] 表示从下标为[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。
"""


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

    for i in range(len(weight)):
        dp[i][0] = 0

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

    # 先遍历背包
    for i in range(1, bag_size + 1):
        for j in range(1, len(weight)):
            if weight[j] > i:
                dp[j][i] = dp[j - 1][i]
            else:
                dp[j][i] = max(dp[j - 1][i], dp[j - 1][i - weight[j]] + value[j])

    # 先遍历物品
    for i in range(1, len(weight)):
        for j in range(1, bag_size + 1):
            if weight[i] > j:
                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][bag_size]


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

一维数组求解

对于背包问题其实状态都是可以压缩的。在使用二维数组的时候，递推公式：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[i - 1]这一层拷贝到dp[i]上，不如只用一个一维数组了，只用dp[j]。

这就是滚动数组的由来，需要满足的条件是上一层可以重复利用，直接拷贝到当前层。

重申一下定义：dp[i][j]** 表示从下标为**[0-i]的物品里任意取，放进容量为j的背包，价值总和最大是多少。

那么，在一维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的价值。（也就是容量为j的背包，放入物品i了之后的价值即：dp[j]）

此时dp[j]有两个选择：

一个是取自己dp[j]，这里相当于二维数组中的dp[i-1][j]，即不放物品i；
一个是取dp[j - weight[i]] + value[i]，即放物品i。

指定是取最大的，即可得到dp[j]。

所以递归公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i])。

初始化：

dp[0]就应该是0，因为背包容量为0所背的物品的最大价值就是0；
其余初始化为0即可，因为从递推公式可以看出，其他的dp会被覆盖。

遍历顺序：二维dp遍历的时候，背包容量是从小到大，而一维dp遍历的时候，背包是从大到小。为什么呢？倒序遍历是为了保证物品i只被放入一次！。但如果一旦正序遍历了，那么物品0就会被重复加入多次！

再来看看两个嵌套for循环的顺序，代码中必须先遍历物品再嵌套遍历背包容量，不可以先遍历背包容量嵌套遍历物品！因为一维dp的写法，背包容量一定是要倒序遍历，如果遍历背包容量放在上一层，那么每个dp[j]就只会放入一个物品，即：背包里只放入了一个物品。

一维数组代码：

# 背包最大重量为4。物品为：
#               重量	价值
#       物品0	1	15
#       物品1	3	20
#       物品2	4	30
# 问背包能背的物品最大价值是多少？

"""
    一维数组实现
        dp[j]表示：容量为j的背包，所背的物品价值可以最大为dp[j]
"""


def wei_bag_problem1(bag_size, weight, value):
    dp = [0 for _ in range(bag_size + 1)]

    # 先遍历物品, 再遍历背包
    for i in range(len(weight)):
        for j in range(bag_size, i, -1): 
            if j >= weight[i]:
                dp[j] = max(dp[j], dp[j - weight[i]] + value[i])
    return dp[-1]


if __name__ == '__main__':
    bag_size = 4
    weight = [1, 3, 4]
    value = [15, 20, 30]
    ret = wei_bag_problem1(bag_size, weight, value)
    print(ret)

经典题目

416. 分割等和子集

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

首先，明确如下四点，其实这道题是一个01背包问题。

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

dp[j]表示背包总容量是j，最大可以凑成j的子集总和为dp[j]。

本题，相当于背包里放入数值，那么物品i的重量是nums[i]，其价值也是nums[i]。所以递推公式：dp[j] = max(dp[j], dp[j - nums[i]] + nums[i])。

从dp[j]的定义来看，首先dp[0]一定是0。如果题目给的价值都是正整数那么非0下标都初始化为0就可以了，如果题目给的价值有负数，那么非0下标就要初始化为负无穷。这样才能让dp数组在递归公式的过程中取的最大的价值，而不是被初始值覆盖了。

class Solution:
    def canPartition(self, nums: List[int]) -> bool:
        '''dp[j]表示 背包总容量是j，最大可以凑成j的子集总和为dp[j]'''
        sums = sum(nums)
        if sums % 2 == 1: return False

        dp = [0] * 10001
        target = sums // 2

        for i in range(0, 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
        else:
            return False

1049. 最后一块石头的重量 II

有一堆石头，用整数数组 stones 表示。其中 stones[i] 表示第 i 块石头的重量。每一回合，从中选出任意两块石头，然后将它们一起粉碎。假设石头的重量分别为 x 和 y，且 x <= y。那么粉碎的可能结果如下：

如果 x == y，那么两块石头都会被完全粉碎；
如果 x != y，那么重量为 x 的石头将会完全粉碎，而重量为 y 的石头新重量为 y-x。

最后，最多只会剩下一块石头。返回此石头最小的可能重量。如果没有石头剩下，就返回 0。

本题其实就是尽量让石头分成重量相同的两堆，相撞之后剩下的石头最小，这其实就是01背包问题。

dp[j]表示容量为j的背包，最多可以背dp[j]这么重的石头。其他的其实和上题一样了。代码如下：

class Solution:
    def lastStoneWeightII(self, stones: List[int]) -> int:
        total_sum = sum(stones)
        target = total_sum // 2
        dp = [0] * (target + 1)

        for i in range(len(stones)):
            for j in range(target, -1, -1):
                if j >= stones[i]:
                    dp[j] = max(dp[j], dp[j - stones[i]] + stones[i])
        
        return total_sum - dp[target] - dp[target]

494. 目标和

给你一个整数数组 nums 和一个整数 target 。向数组中的每个整数前添加 ‘+’ 或 ‘-’ ，然后串联起所有整数，可以构造一个表达式：

例如，nums = [2, 1] ，可以在 2 之前添加 ‘+’ ，在 1 之前添加 ‘-’ ，然后串联起来得到表达式 “+2-1”

返回可以通过上述方法构造的、运算结果等于 target 的不同表达式的数目。

假设加法的总和为x，那么减法对应的总和就是sum - x。所以我们要求的是 x - (sum - x) = target，解方程，即有x = (S + sum) / 2。此时问题就转化为，装满容量为x背包，有几种方法。

首先，上面的x求解涉及到除法，那么就需要考虑向下取整有没有影响：

(S + sum) % 2 == 1：很显然，这种情况无解！
abs(target) > sum：这种情况也没有解，毕竟目标和都比数组的和大了，咋可能会有解呢？

dp[j]表示：填满j（包括j）这么大容积的包，有dp[j]种方法。

不考虑nums[i]的情况下，填满容量为j - nums[i]的背包，有dp[j - nums[i]]种方法。那么只要搞到nums[i]的话，凑成dp[j]就有dp[j - nums[i]]种方法。那么凑整dp[j]有多少方法呢，也就是把所有的 dp[j - nums[i]] 累加起来。

求组合类问题的公式，都是类似这种：

dp[j] += dp[j - nums[i]]

从递归公式可以看出，在初始化的时候dp[0] 一定要初始化为1，因为dp[0]是在公式中一切递推结果的起源，如果dp[0]是0的话，递归结果将都是0。dp[0] = 1，理论上也很好解释，装满容量为0的背包，有1种方法，就是装0件物品。

代码实现如下：

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

        if abs(target) > total_sum: return 0
        if (target + total_sum) % 2 == 1: return 0

        bagsize = (target + total_sum) // 2

        dp = [0] * (bagsize + 1)
        dp[0] = 1  # 装满容量为0的背包，有1种方法，就是装0件物品

        for i in range(len(nums)):
            for j in range(bagsize, nums[i] - 1, -1):
                dp[j] += dp[j - nums[i]]
        
        return dp[bagsize]

474. 一和零（🧡🧡）

给你一个二进制字符串数组 strs 和两个整数 m 和 n 。请你找出并返回 strs 的最大子集的长度，该子集中最多有 m 个 0 和 n 个 1 。如果 x 的所有元素也是 y 的元素，集合 x 是集合 y 的子集。

要注意，本题不是多重背包，本题中 strs 数组里的元素就是物品，每个物品都是一个！而m 和 n相当于是一个背包，两个维度的背包。仔细理解一下这里！

dp[i][j]：最多有i个0和j个1的strs的最大子集的大小为dp[i][j]。

dp[i][j]可以由前一个strs里的字符串推导出来，strs里的字符串有zeroNum个0，oneNum个1。dp[i][j]就可以是 dp[i - zeroNum][j - oneNum] + 1。然后我们在遍历的过程中，取dp[i][j]的最大值。所以递推公式：dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1)。

对比一下标准01背包问题就会发现，字符串的zeroNum和oneNum相当于物品的重量（weight[i]），字符串本身的个数相当于物品的价值（value[i]）。这就是一个典型的01背包！只不过物品的重量有了两个维度而已。

代码实现如下：

class Solution:
    def findMaxForm(self, strs: List[str], m: int, n: int) -> int:
        dp = [[0 for _ in range(n + 1)] for _ in range(m + 1)]        

        for s in strs:
            oneNum, zeroNum = s.count("1"), s.count("0")

            for i in range(m, zeroNum - 1, -1):
                for j in range(n, oneNum - 1, -1):
                    dp[i][j] = max(dp[i][j], dp[i - zeroNum][j - oneNum] + 1)
            
        return dp[m][n]