什么是动态规划
- 动态规划法试图只解决每个子问题一次
- 一旦某个给定子问题的解已经算出,则将其记忆化存储,以便下次需要同一个子问题解之时直接查表。
「动态规划」中包含三个重要的概念:
【最优子结构】
【边界】
【状态转移公式】
在「 斐波那契数列问题 」中
f(10) = f(9) + f(8) 是【最优子结构】
f(0) 与 f(1) 是【边界】
f(n) = f(n-1) + f(n-2) 【状态转移公式】
斐波那契数列
额外空间,n+1长度数组(0,1,…,n)
自顶向下
if n == 0:
memo[0] = 0
if n == 1:
memo[1] = 1
if memo[n] == [0]:
meno[n] = memo[n-1] + memo[n-2]
return memo[n]
自底向上
memo[0] = 0
memo[1] = 1
for i in range(2,n+1):
memo[i] = memo[i-1]+memo[i-2]
return memo[n]
分割数求最大乘积
用回溯暴力搜索的思路,有重叠子问题
更一般的,
自顶向下
class Solution:
def integerBreak(self, n: int) -> int:
memo = [-1]*(n+1)
return self.breakint(n,memo)
#将n进行分割,至少分割两部分,可以得到的最大乘积
def breakint(self,n,memo):
if n == 1:
return 1
if memo[n] != -1:
return memo[n]
res = -1
for i in range(1,n): #注意递归从1开始,取到n-1
# 分割为 i + n-i
# 从以前最大,当前不向下分割,当前继续向下分割这3个中选最大的
res = max(res,max(i*(n-i), i*self.breakint(n-i,memo)))
memo[n] = res
return res
自底向上
复杂度O(n^2),n取17时,超时无法通过
class Solution:
def integerBreak(self, n: int) -> int:
memo = [-1]*(n+1)
memo[1] = 1
for i in range(2,n+1):
for j in range(1,i):
#j + i-j
memo[i] = max(memo[i],max(j*(i-j), j*self.integerBreak(i-j)))
return memo[n]
House Robber
考虑表示不一定偷X,v(0)表示偷0。
自顶向下
自底向上
换一种定义状态的方式
dp[i]表示考虑抢劫 nums[0…i] 所能获得的最大收益
class Solution:
def rob(self, nums: List[int]) -> int:
if not nums: return 0
if len(nums) == 1: return nums[0]
dp = [[0] for _ in range(len(nums))]
dp[0] = nums[0]
dp[1] = max(nums[0], nums[1])
for i in range(2, len(nums)):
# rob this house or the previous one
dp[i] = max(dp[i-1], dp[i-2] + nums[i])
return dp[-1]
矩阵中的最长递增路径
- Longest Increasing Path in a Matrix
自顶向下
def longestIncreasingPath(self, matrix):
def dfs(i, j):
if not dp[i][j]: # 如果没有被访问过,这里把visited和存储矩阵和在一起了
val = matrix[i][j]
dp[i][j] = 1 + max(
dfs(i - 1, j) if i and val > matrix[i - 1][j] else 0, # 保证访问数组不越界
dfs(i + 1, j) if i < M - 1 and val > matrix[i + 1][j] else 0,
dfs(i, j - 1) if j and val > matrix[i][j - 1] else 0,
dfs(i, j + 1) if j < N - 1 and val > matrix[i][j + 1] else 0)
return dp[i][j]
if not matrix or not matrix[0]: return 0
M, N = len(matrix), len(matrix[0])
dp = [[0] * N for i in range(M)] # 存储到达当前位置的最长路径长度
return max(dfs(x, y) for x in range(M) for y in range(N))
自己实现的
class Solution:
def inarea(self, x, y, m, n):
if 0 <= x < m and 0 <= y < n:
return True
return False
def dfs(self, matrix, x, y, dp):
m = len(matrix)
n = len(matrix[0])
d = [[1,0],[0,1],[-1,0],[0,-1]]
if dp[x][y]:
return dp[x][y]
res = 1
for i in range(4): # 对上下左右递归
nx = x + d[i][0]
ny = y + d[i][1]
if self.inarea(nx, ny, m, n) is True and matrix[nx][ny] < matrix[x][y]: #递增,此处等号不可取,取了会无限循环。
res = max(res, self.dfs(matrix, nx, ny, dp)+1)
dp[x][y] = res #此处更新的是当前位置的最大长度,不是nx,ny的
return res
def longestIncreasingPath(self, matrix: List[List[int]]) -> int:
m = len(matrix)
if not m: #对[]输入的处理
return 0
n = len(matrix[0])
if not n:
return 0
res = 0
dp = [[0]*n for i in range(m)]
for i in range(m):
for j in range(n):
res = max(res, self.dfs(matrix, i, j, dp))
return res