动态规划原理及例题

什么是动态规划

1. 动态规划法试图只解决每个子问题一次
2. 一旦某个给定子问题的解已经算出，则将其记忆化存储，以便下次需要同一个子问题解之时直接查表。

「动态规划」中包含三个重要的概念：

【最优子结构】
【边界】
【状态转移公式】

在「 斐波那契数列问题 」中

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]

矩阵中的最长递增路径

329. 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