leetcode动态规划—完全背包系列

Ymmmm__

于 2025-05-30 15:18:39 发布

阅读量596

点赞数 11

CC 4.0 BY-SA版权

分类专栏：动态规划文章标签： leetcode 动态规划算法

本文链接：https://blog.youkuaiyun.com/Ymmmm__/article/details/148308049

动态规划专栏收录该内容

6 篇文章

订阅专栏

刷完这个系列的经验之谈

分为三类

1、求最值（最大价值、最小长度）——对应这的理论基础与lc322零钱兑换

2、求组合——对应lc518零钱兑换

3、求排列——对应lc377组合总和IV、lc57爬楼梯进阶

遍历顺序：

最值：可以颠倒，因为最后都是最值更新，不会重复计算组合

组合：只能是先物品-后背包，否则会重复计算组合

排列：只能是先背包-后物品，否则漏掉排列（排列问题一律看作爬楼梯

完全背包基础理论题

完全背包就是每个物品的数量是不限的，可以多次选择。

二维来看，核心区别就是动态转移方程的改变：

dp[i][j] = max(dp[i-1][j], dp[i][j-weights[i]])

1、不选i，为dp[i-1][j]（这点与0-1背包无区别）

2、选i，但之前还可以选过i，则为dp[i][j-weights[i]]，而非dp[i-1][j-weights[i]]

一维来看，就是遍历顺序改变了，因为每一行都要根据当前行的左侧状态进行转移，所以就是顺序遍历

二维方法

import sys
input = sys.stdin.read
data = input().split()
index = 0
n = int(data[index])
index += 1
v = int(data[index])
index += 1
weights = []
values = []
for _ in range(n):
    weights.append(int(data[index]))
    index += 1
    values.append(int(data[index]))
    index += 1
 
#dp[i][j]:选择【0-i】物品，容量为j的背包最大价值为dp[i][j]
#dp[i][j] = max(dp[i-1][j], dp[i][j-weights[i]]+values[i])
#求解dp[n-1][v]
 
#初始化
dp = [[0] * (v+1) for _ in range(n)]
for j in range(weights[0], v+1):
    dp[0][j] = dp[0][j-weights[0]] + values[0]
 
 
for i in range(1, n):
    for j in range(1, v+1):
        if j < weights[i]:
            dp[i][j] = dp[i-1][j]
        else:
            dp[i][j] = max(dp[i-1][j], dp[i][j-weights[i]]+values[i])
print(dp[n-1][v])

一维方法

import sys
input = sys.stdin.read
data = input().split()
index = 0
n = int(data[index])
index += 1
v = int(data[index])
index += 1
weights = []
values = []
for _ in range(n):
    weights.append(int(data[index]))
    index += 1
    values.append(int(data[index]))
    index += 1

#dp[j]:容量为j的背包最大价值为dp[j]
#dp[j] = max(dp[j], dp[j-weights[i]]+values[i])
#求解dp[v]
dp = [0] * (v+1)

#遍历——左to右
for i in range(n):
    for j in range(weights[i], v+1):
        dp[j] = max(dp[j], dp[j-weights[i]]+values[i])
print(dp[v])

lc518 零钱兑换

注意这是组合问题，而非排列问题，所以遍历顺序很重要，一定要先遍历物品

遍历物品：

对于每个物品都是按顺序遍历的，所以物品i+1不会出现在i之前，这就避免了重复组合

二维方法

class Solution:
    def change(self, amount: int, coins: List[int]) -> int:
        #dp[i][j]:用【0-i】钱币装满容量为j的背包组合数为dp[i][j]
        #dp[i][j] = dp[i-1][j] + dp[i][j-coins[i]]
        #求解dp[n-1][amount]
        n = len(coins)
        dp = [[0] * (amount+1) for _ in range(n)]
        
        #初始化
        for i in range(n):
            dp[i][0] = 1
        for j in range(amount+1):
            if j % coins[0] == 0:
                dp[0][j] = 1
        #遍历
        for i in range(1, n):
            for j in range(1, amount+1):
                if j < coins[i]:
                    dp[i][j] = dp[i-1][j]
                else:
                    dp[i][j] = dp[i-1][j] + dp[i][j-coins[i]]
        return dp[n-1][amount]

一维方法

class Solution:
    def change(self, amount: int, coins: List[int]) -> int:
        #dp[j]:容量为j的背包被装满的组合数为dp[j]
        #dp[j] = dp[j] + dp[j-coins[i]]
        #求解dp[amount]
        dp = [0] * (amount+1)
        
        dp[0] = 1
        
        for i in range(len(coins)):
            for j in range(coins[i], amount+1):
                dp[j] = dp[j] + dp[j-coins[i]]
        return dp[amount]

lc377 组合总和IV(看作爬楼梯）(求的是排列排列排列！！！！！！！！！！）

二维方法(不好理解，可以不看）

dp数组含义变了（注释）

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

不选i：dp[i-1][j]

选i：之前的排列要考虑到所有物品，而不能只考虑【0， i-1】物品，所以为dp[-1][j-num[i]]
最后一行是考虑了所有物品的排列可能的

特殊处理i==0这种情况，不然i-1为-1时转移不合理。

class Solution:
    def combinationSum4(self, nums: List[int], target: int) -> int:
        #dp[i][j]:最后一个考虑（选or不选）的物品为i，装满容量为j的背包的排列数为dp[i][j]
        #dp[i][j] = dp[i-1][j] + dp[-1][j-nums[i]]
        #求解dp[n-1][target]
        n = len(nums)
        dp = [[0] * (target+1) for _ in range(n)]
        #初始化
        for i in range(n):
            dp[i][0] = 1

        #遍历
        for j in range(1, target+1):
            for i in range(n):
                if i == 0:
                    if j < nums[i]:
                        dp[i][j] = 0
                    else:
                        dp[i][j] = 0 + dp[-1][j-nums[i]]
                else:
                    if j < nums[i]:
                        dp[i][j] = dp[i-1][j]
                    else:
                        dp[i][j] = dp[i-1][j] + dp[-1][j-nums[i]]
        return dp[n-1][target]

一维方法

可以看作爬楼梯问题

dp[j]：爬上j阶楼梯的走法有dp[j]种，每次面临nums个选择

则dp[j]完全由dp[j-nums[i]]的总和决定

class Solution:
    def combinationSum4(self, nums: List[int], target: int) -> int:
        n = len(nums)
        #dp[j] : 装满容量为j的背包的排列数为dp[j]
        #dp[j] = dp[j] + dp[j-nums[i]]
        #求解dp[target]
        dp = [0] * (target+1)
        dp[0] = 1
        for j in range(target+1):
            for i in range(n):
                if j >= nums[i]:
                    dp[j] = dp[j] + dp[j-nums[i]] 
        return dp[target]

lc57 爬楼梯进阶

dp[j]：爬上j阶楼梯的走法有dp[j]种，每次面临nums个选择

则dp[j]完全由dp[j-nums[i]]的总和决定

import sys
input = sys.stdin.read
data = input().split()
index = 0
n = int(data[index])
index += 1
m = int(data[index])
#dp[j] : 容量为j的背包装满的排列数为dp[j]
#dp[j] = dp[j] + dp[j-i]
#求解dp[n]
dp = [0] * (n+1)
dp[0] = 1

#遍历
for j in range(1, n+1):
    for i in range(1, m+1):
        if j >= i:
            dp[j] = dp[j] + dp[j-i]
print(dp[n])

lc322 零钱兑换

因为是选取最小值，所以初始化为最大值

二维方法

class Solution:
    def coinChange(self, coins: List[int], amount: int) -> int:
        #dp[i][j]：使用【0-i】硬币，装满容量为amount的背包，使用的最少硬币数为dp[i][j]
        #dp[i][j] = min(dp[i-1][j], dp[i][j-coins[i]]+1)
        #求解dp[n-1][amount]
        n = len(coins)
        dp = [[float('inf')] * (amount+1) for _ in range(n)]
        
        for i in range(n):
            dp[i][0] = 0
        for j in range(1, amount+1):
            if j % coins[0] == 0:
                dp[0][j] = j // coins[0]
        for i in range(1, n):
            for j in range(1, amount+1):
                if j < coins[i]:
                    dp[i][j] = dp[i-1][j]
                else:
                    dp[i][j] = min(dp[i-1][j], dp[i][j-coins[i]]+1)
        if dp[n-1][amount] == float('inf'):
            return -1
        return dp[n-1][amount]

一维方法

class Solution:
    def coinChange(self, coins: List[int], amount: int) -> int:
        #dp[j] : 装满容量为j的背包，最少的硬币数目为dp[j]
        #dp[j] = min(dp[j], dp[j-coins[i]]+1)
        #求解dp[amount]
        n = len(coins)

        #初始化
        dp = [float('inf')] * (amount+1)
        dp[0] = 0

        for i in range(n):
            for j in range(coins[i], amount+1):
                dp[j] = min(dp[j], dp[j-coins[i]]+1)
        if dp[amount] == float('inf'):
            return -1
        return dp[amount]

lc279 完全平方数

class Solution:
    import math
    def numSquares(self, n: int) -> int:
        #dp[j] : 容量为j的背包装满的最小长度为dp[j]
        #dp[j] = min(dp[j], dp[j-num]+1)
        #求解dp[n]

        #初始化
        dp = [float('inf')] * (n+1)
        dp[0] = 0

        for i in range(1, int(math.sqrt(n)+1)):
            for j in range(i**2, n+1):
                dp[j] = min(dp[j], dp[j-i**2]+1)
        return dp[n]

lc139 单词拆分

排列问题就用“爬楼梯思想”

class Solution:
    def wordBreak(self, s: str, wordDict: List[str]) -> bool:
        wordDict = set(wordDict)
        n = len(s)
        #dp[j]: j阶楼梯能否爬上，即s【0 : j】能否成功构造
        #dp[j] 由 dp[j-k]决定，即从当前s[j-1]开始往前搜，看是否存在于set，且之前的台阶能否够上
        #求解dp[n]
        dp = [False] * (n+1)
        dp[0] = True
        for j in range(1, n+1):
            for k in range(j, -1, -1):
                if s[k-1 : j] in wordDict and dp[k-1] == True:
                    dp[j] = True
        return dp[n]