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

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

标准0-1背包问题

二维数组求解

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

每一件物品其实只有两个状态,取或者不取,所以可以使用回溯法搜索出所有的情况,那么时间复杂度就是 o ( 2 n ) o(2^n) o(2n),这里的 n 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])

初始化:

  1. dp[i][j]的定义出发,如果背包容量j为0的话,即dp[i][0],无论是选取哪些物品,背包价值总和一定为0。
  2. 从状态转移方程可以看出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]有两个选择:

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

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

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

初始化:

  1. dp[0]就应该是0,因为背包容量为0所背的物品的最大价值就是0;
  2. 其余初始化为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背包问题就会发现,字符串的zeroNumoneNum相当于物品的重量(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]

可以理解为有两维的一维数组的01背包问题。

你可能感兴趣的:(#,LeetCode,动态规划,leetcode,背包问题)