leetcode(21)其他动态规划相关题目
509. 斐波那契数
方法1：使用数组将动态规划每个状态存下来
时间复杂度\(O(n)\)、空间复杂度\(O(n)\)
class Solution:
def fib(self, n: int) -> int:
if n == 0:return 0
f = [0] * (n+1)
f[1] = 1
for i in range(2, n + 1):
f[i] = f[i - 1] + f[i - 2]
return f[n]
方法2：只需要维护两个数值就可以了，不需要记录整个序列
时间复杂度\(O(n)\)、空间复杂度\(O(1)\)
class Solution:
def fib(self, n: int) -> int:
if n < 2:return n
res = 0
pre, cur = 0, 1
for _ in range(1, n)
res = pre + cur
pre, cur = cur, res
return res
方法3：递归
时间复杂度\(O(n^2)\)、空间复杂度\(O(n)\)
class Solution:
def fib(self, n: int) -> int:
if n < 2:return n
return self.fib(n - 1) + self.fib(n - 2)
70. 爬楼梯
注意：递归会超时
class Solution:
def climbStairs(self, n: int) -> int:
if n < 3: return n
a, b, res = 1, 2, 0
for _ in range(2, n):
res = a + b
a, b = b, res
return res
746. 使用最小花费爬楼梯
最后一步如果是从第n-1爬上去的则不用+cost[i]，因此直接比较最后两步的大小
class Solution:
def minCostClimbingStairs(self, cost: List[int]) -> int:
n = len(cost)
dp = [0] * n
dp[0], dp[1] = cost[0], cost[1]
for i in range(2, n):
dp[i] = min(dp[i - 1], dp[i - 2]) + cost[i]
return min(dp[n - 1], dp[n - 2])
62. 不同路径
动态规划，dp[i][j] ：表示从（0 ，0）出发，到(i, j) 有dp[i][j]条不同的路径。
class Solution:
def uniquePaths(self, m: int, n: int) -> int:
dp = [[1] * n for _ in range(m)]
# print(dp)
for i in range(1, m):
for j in range(1, n):
dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
return dp[-1][-1]
63. 不同路径 II
dp初始化为0,注意代码里for循环的终止条件，一旦遇到obstacleGrid[i][0] == 1的情况就停止dp[i][0]的赋值1的操作，dp[0][i]同理
class Solution:
def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
m, n = len(obstacleGrid), len(obstacleGrid[0])
dp = [[0] * n for _ in range(m)]
for i in range(m):
if obstacleGrid[i][0] == 1: break
dp[i][0] = 1
for j in range(n):
if obstacleGrid[0][j] == 1: break
dp[0][j] = 1
# print(dp)
for i in range(1, m):
for j in range(1, n):
if obstacleGrid[i][j] != 1: # 只用这一个限制条件即可
dp[i][j] = dp[i][j - 1] + dp[i - 1][j]
return dp[-1][-1]
343. 整数拆分
假设对正整数 i 拆分出的第一个正整数是 j（1 <= j < i），则有以下两种方案：
- 将 i 拆分成 j 和 i−j 的和，且 i−j 不再拆分成多个正整数，此时的乘积是 j * (i-j)
- 将 i 拆分成 j 和 i−j 的和，且 i−j 继续拆分成多个正整数，此时的乘积是 j * dp[i-j]
class Solution:
def integerBreak(self, n: int) -> int:
dp = [1] * (n+1) # 初始值可以赋为1
# dp[0], dp[1] = 1, 1
for i in range(3, n + 1):
for j in range(1, i // 2 + 1): # 只要遍历一半即可
dp[i] = max(dp[i], j * (i - j), j * dp[i - j]) # 每次比较之后更新dp[i]
print(dp)
return dp[-1]
96. 不同的二叉搜索树
class Solution:
def numTrees(self, n: int) -> int:
dp = [0] * (n + 1) # 初始值不可以赋为1
dp[0], dp[1] = 1, 1
for i in range(2, n + 1):
for j in range(1, i + 1):
dp[i] += dp[j - 1] * dp[i - j] # 左边节点数量乘右边节点数量
return dp[-1]
118. 杨辉三角
class Solution:
def generate(self, numRows: int) -> List[List[int]]:
res = []
for i in range(numRows):
res.append([]) # 循环i次，添加i个[]
for j in range(i + 1):
if j == 0 or j == i:
res[i].append(1)
else:
res[i].append(res[i - 1][j - 1] + res[i - 1][j])
return res
119. 杨辉三角 II
class Solution:
def getRow(self, rowIndex: int) -> List[int]:
res = []
for i in range(rowIndex + 1):
res.append([])
for j in range(i + 1):
if j == 0 or j == i:
res[i].append(1)
else:
res[i].append(res[i - 1][j - 1] + res[i - 1][j])
return res[-1]
198. 打家劫舍
注意打劫第二家的时候就要初始化为max(nums[0], nums[1])
class Solution:
def rob(self, nums: List[int]) -> int:
n = len(nums)
if n == 1:return nums[0]
dp = [0] * n
dp[0] = nums[0]
dp[1] = max(nums[0], nums[1])
for i in range(2, n):
dp[i] = max(dp[i - 2] + nums[i], dp[i -1])
return dp[-1]
213. 打家劫舍 II
把环形分成两个单排，分两种情况考虑：
一是不偷第一间房，二是不偷最后一间房
class Solution:
def help(self, nums):
n = len(nums)
if n == 1:return nums[0]
dp = [0] * n
dp[0] = nums[0]
dp[1] = max(nums[0], nums[1])
for i in range(2, n):
dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])
return dp[-1]
def rob(self, nums: List[int]) -> int:
if len(nums) == 1:return nums[0]
return max(self.help(nums[1:]), self.help(nums[:-1]))
337. 打家劫舍 III
dp数组以及下标的含义：
- 下标为 0 记录 不偷该节点 所得到的最大金钱
- 下标为 1 记录 偷该节点 所得到的最大金钱
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
def rob(self, root: Optional[TreeNode]) -> int:
dp = self.traversal(root)
return max(dp)
def traversal(self, root):
if not root:
return (0, 0)
left = self.traversal(root.left)
right = self.traversal(root.right)
not_rob = max(left[0], left[1]) + max(right[0], right[1])
rob_cur = root.val + left[0] + right[0]
return (not_rob, rob_cur)
413. 等差数列划分
定义 dp[i] 是以 A[i] 为终点的等差数列的个数
class Solution:
def numberOfArithmeticSlices(self, nums: List[int]) -> int:
if len(nums) < 3:return 0
dp = [0] * len(nums)
for i in range(2, len(nums)):
if nums[i] - nums[i - 1] == nums[i - 1] - nums[i - 2]:
dp[i] = dp[i - 1] + 1
return sum(dp)
887. 鸡蛋掉落
dp[i][j] 表示为：一共有 i 个鸡蛋，最多扔 j 次鸡蛋（碎没碎都算 1 次）的条件下，最多可以检测的楼层个数。
状态转移方程：
现在有 i 个鸡蛋，j 次扔鸡蛋的机会，现在尝试在 1 ~ n 层中的任意一层 x 扔鸡蛋：
如果鸡蛋没碎，剩下 i 个鸡蛋，还有 j - 1 次扔鸡蛋的机会，最多可以检测 dp[i][j - 1] 层楼层。
如果鸡蛋碎了，剩下 i - 1 个鸡蛋，还有 j - 1 次扔鸡蛋的机会，最多可以检测 dp[i - 1][j - 1] 层楼层。
再加上我们扔鸡蛋的第 x 层，i 个鸡蛋，j 次扔鸡蛋的机会最多可以检测 dp[i][j - 1] + dp[i - 1][j - 1] + 1 层。
则状态转移方程为：dp[i][j] = dp[i][j - 1] + dp[i - 1][j - 1] + 1
class Solution:
def superEggDrop(self, k: int, n: int) -> int:
dp = [[0] * (n + 1) for _ in range(k + 1)]
dp[1][1] = 1
for i in range(1, k + 1):
for j in range(1, n + 1):
dp[i][j] = dp[i][j - 1] + dp[i - 1][j - 1] + 1
if i == k and dp[i][j] >= n:
return j
return n
764. 最大加号标志
从四个方向分别搜索
class Solution:
def orderOfLargestPlusSign(self, n: int, mines: List[List[int]]) -> int:
dp = [[n] * n for _ in range(n)] # 初始化时假设一行全是1
for x, y in mines:
dp[x][y] = 0
for k in range(n):
i, j = 0, n - 1
l, r, u, d = 0, 0, 0, 0
while i < n:
l = l + 1 if dp[k][i] else 0
r = r + 1 if dp[k][j] else 0
u = u + 1 if dp[i][k] else 0
d = d + 1 if dp[j][k] else 0
dp[k][i] = min(dp[k][i], l)
dp[k][j] = min(dp[k][j], r)
dp[i][k] = min(dp[i][k], u)
dp[j][k] = min(dp[j][k], d)
i += 1
j -= 1
# print(dp)
# print(max(dp)) # 返回第一列最大的那一行
return max(max(i) for i in dp)
790. 多米诺和托米诺平铺
数学归纳法推导公式
class Solution:
def numTilings(self, n: int) -> int:
if n == 1:return 1
MOD = 10 ** 9 + 7
dp = [0] * (n + 1)
dp[0] = dp[1] = 1
dp[2] = 2
for i in range(3, n + 1):
dp[i] = (dp[i - 1] * 2 + dp[i - 3]) % MOD
return dp[-1]
799. 香槟塔
有点类似于杨辉三角，使用层序号初始化下一层杯子的数量
class Solution:
def champagneTower(self, poured: int, query_row: int, query_glass: int) -> float:
cur_row = [poured]
for i in range(1, query_row + 1):
next_row = [0] * (i + 1)
for j, v in enumerate(cur_row):
if v > 1:
next_row[j] += (v - 1)/2
next_row[j + 1] += (v - 1)/2
cur_row = next_row
return min(1, cur_row[query_glass])
