代码随想录Day24|动态规划1|基础入门

一维动规基础

509.斐波那契数

• 动规入门
• 递归和动规两种写法

class Solution:
    def fib(self, n: int) -> int:
        if n<=1:
            return n
        dp = [0]*(n+1)
        dp[1] = 1
        for i in range(2,n+1):
            dp[i] = dp[i-1] + dp[i-2]
        return dp[-1]

## 递归写法
class Solution:
    def fib(self, n: int) -> int:
        if n<=1:
            return n
        return self.fib(n-1)+self.fib(n-2)

70.爬楼梯

• 动规入门2

class Solution:
    def climbStairs(self, n: int) -> int:
        dp = [0]*(n+1)
        dp[0],dp[1] = 1,1
        for i in range(2,n+1):
            dp[i] = dp[i-1] + dp[i-2]
        return dp[-1]

746.使用最小花费爬楼梯

• 动规入门3
• 两种写法

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] = cost[i]+min(dp[i-1],dp[i-2])
        return min(dp[-1],dp[-2])

## 更简洁
class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        n = len(cost)+1
        dp = [0]*n
        for i in range(2,n):
            dp[i] = min(cost[i-1]+dp[i-1],cost[i-2]+dp[i-2])
        return dp[-1]

二维动规入门

62.不同路径

• 由于动规初始化当前值根本不用

class Solution:
    def uniquePaths(self, m: int, n: int) -> int:
        
        #dp = [[0]*n for j in range(m)]
        #for i in range(m):
        #    dp[i][0] = 1
        #for j in range(n):
        #    dp[0][j] = 1
        ## 以上代码可以简化下面这列
        
        dp = [[1]*n for j in range(m)]
        for i in range(1,m):
            for j in range(1,n):
                dp[i][j] = dp[i][j-1] + dp[i-1][j]

        return dp[-1][-1]

63.不同路径Ⅱ

• 注意初始化

class Solution:
    def uniquePathsWithObstacles(self, obstacleGrid: List[List[int]]) -> int:
        m,n = len(obstacleGrid),len(obstacleGrid[0])
        dp = [[0]*n for i in range(m)]

        for i in range(m):
            if obstacleGrid[i][0]:
                break
            dp[i][0] = 1
        
        for j in range(n):
            if obstacleGrid[0][j]:
                break
            dp[0][j] = 1

        for i in range(1,m):
            for j in range(1,n):
                if not obstacleGrid[i][j]:
                    dp[i][j] = dp[i-1][j] + dp[i][j-1]
    
        return dp[-1][-1]

思考动规状态转化

343.整数拆分

• 初始化 需要注意 1-3是质数，本身值最大

class Solution:
    def integerBreak(self, n: int) -> int:
        if n<=3:
            return n-1
        dp = [0]*(n+1)
        dp[1],dp[2],dp[3] = 1,2,3
        for i in range(2,n+1):
            for j in range(1,i):
                dp[i] = max(dp[i],j*dp[i-j])
        return dp[-1]

96.不同的二叉搜索树

• 重点在思考状态转移方程
• 每个数都可以拿出来作为根节点，当前数为根节点时，左右两边子树的数量个数相乘即为当前的和。根据二叉搜索树的特性，刚好是连续的 0-n—1，1-n—2…n-1—1.

class Solution:
    def numTrees(self, n: int) -> int:
        if n<=2:
            return n
        dp = [0]*(n+1)
        dp[0],dp[1],dp[2] = 1,1,2
        for i in range(3,n+1):
            for j in range(i):
                dp[i] += dp[j]*dp[i-j-1]
        
        return dp[-1]