刷题第三十二天 动态规划启动 509. 斐波那契数 70. 爬楼梯 746. 最小花费爬楼梯

动态规划五部曲

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

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

斐波那契数，递归解决，时间复杂度有点高。用动态规划，递推公式就是斐波那契的公式

class Solution:
    def climbStairs(self, n: int) -> int:
        # 到达第n阶台阶的方式是到达第n-1阶的加上第n-2阶的
        if n <= 2:
            return n
        dp = [0] * (n + 1)
        dp[0] = 0
        dp[1] = 1
        dp[2] = 2
        for i in range(3, n + 1):
            dp[i] = dp[i - 1] + dp[i - 2]
        return dp[n]

爬楼梯问题，只要想到到达第i层台阶只有两种方式，一种从i-1上来，另一种从i-2上来，所以递推公式就是到达第i层台阶的方式为第i-1层的方式 加上第i-2层的方式。

class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        if len(cost) == 1:
            return cost[0]
        if len(cost) == 2:
            return min(cost[0], cost[1])
        dp = [0] * (len(cost) + 1) #到达第i台阶已经花了多少钱
        dp[0] = 0
        dp[1] = 0
        for i in range(2, len(cost) + 1):
            dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]) #到达第i台阶的钱是到达第i-1的钱加上i-1向上走要花的钱和到达第i-2的钱加上i-2向上走要画的钱的较小的那个
        return dp[len(cost)]

多了一个从台阶向上跳的花费。递推公式就变成了第i层的花费是第i-1层的花费加上i-1向上跳需要的花费以及第i-2层的花费加上i-2向上跳需要的花费两者最小值。