代码随想录算法训练营第四十二天 | 509. 斐波那契数，70. 爬楼梯，746. 使用最小花费爬楼梯

509. 斐波那契数

分析一

1. 确定dp数组（dp table）以及下标的含义
   表示以每个数作为终点的斐波那契数列之和

2. 确定递推公式
   F(n) = F(n - 1) + F(n - 2)

3. dp数组如何初始化
   [0,1,0,…,0]? 先初始化 F(0) 和 F(1) 其他都是0

4. 确定遍历顺序
   从小到大

5. 举例推导dp数组
   F(0) = 0
   F(1) = 1
   F(2) = F(1) + F(0) = 0 + 1 = 1
   F(3) = F(2) + F(1) = 1 + 1 = 2
   F(4) = F(3) + F(2) = 2 + 1 = 3
   …

class Solution:
    def fib(self, n: int) -> int:
        F = [0, 1] + [0] * (n - 1)

        for i in range(2, n + 1):
           F[i] = F[i - 1] + F[i - 2]

        return F[n] 

70. 爬楼梯

分析一(内存溢出了)

1. 确定dp数组（dp table）以及下标的含义
   二叉树（n + 1 层）？用数组表示二叉树，每个节点的值表示剩余的阶梯数量，数组元素个数为 2 ** (n + 1) - 1
2. 确定递推公式
   dp[2i + 1] = dp[i] - 1
   dp[2i + 2] = dp[i] - 2
3. dp数组如何初始化
   [n, -1, -1, -1, …, -1] 第一个元素初始化为阶梯数量，其余的为-1，为了分辨是否到达了某个阶梯
4. 确定遍历顺序
   从 [0, 2 ** n - 1)
5. 举例推导dp数组
   n = 3
   [0 ~ 7)
   dp[0] = 3
   dp[1] = 2
   dp[2] = 1
   dp[3] = 1
   dp[4] = 0
   dp[5] = 0
   dp[6] = -1
   dp[7] = 0
   dp[8] = -1
   dp[9] = -1
   dp[10] = -1
   dp[11] = -1
   dp[12] = -1
   dp[13] = -1
   dp[14] = -1
   有 3 个为 0 的节点，那就有3种方法

分析二（正解）

1. 确定dp数组（dp table）以及下标的含义
   dp数组中每个元素表示到达该层有多少种方法
2. 确定递推公式
   dp[i] = dp[i - 1] + dp[i - 2]
3. dp数组如何初始化
   [1, 1, 0, 0, …, 0] 第0层设为1，第1层设为1，其余设为0
4. 确定遍历顺序
   从 [0, n]
5. 举例推导dp数组
   n = 4
   dp[3] = dp[2] + dp[1] = 2 + 1 = 3
   dp[4] = dp[3] + dp[2] = 3 + 2 = 5

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

746. 使用最小花费爬楼梯

分析一

1. 确定dp数组（dp table）以及下标的含义
   dp 数组表示爬楼梯的最小花费，下标表示层数

2. 确定递推公式
   dp[i] = min(dp[i - 2] + cost[i - 2], dp[i - 1] + cost[i - 1])

3. dp数组如何初始化
   dp[0] = 0, dp[1] = 0，其余为 0 （因为可以选择从下标为0或下边为1的台阶开始爬楼梯）
   dp的元素总数比 cost 数组多一个，因为包含顶楼

4. 确定遍历顺序
   从低层到高层

5. 举例推导dp数组
   cost = [10, 15, 20]
   dp[0] = 0, dp[1] = 0
   dp[2] = min(dp[0] + cost[0], dp[1] + cost[1]) = min(10, 15) = 15

class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        dp = [0] * (len(cost) + 1)

        for i in range(2, len(cost) + 1):
            dp[i] = min(dp[i - 2] + cost[i - 2], dp[i - 1] + cost[i - 1])
        
        return dp[-1]