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

刷完这个系列的经验之谈

分为三类

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 += 1values.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 += 1values.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] = 1for 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] = 1for 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] = 0else: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] = 1for 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] = 0for 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 -1return 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] = 0for 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 -1return dp[amount]

lc279 完全平方数

class Solution:import mathdef 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] = 0for 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] = Truefor 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] = Truereturn dp[n]