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

1.动态规划基础

文档讲解： 代码随想录

对于动态规划，拆解为五步：
（1）dp数组以及下标的含义
（2）递推公式
（3）dp数组如何初始化
（4）遍历顺序
（5）举例推导dp数组（打印数组）

2.509. 斐波那契数

题目链接：509. 斐波那契数
文档讲解： 代码随想录

class Solution(object):
    def fib(self, n):
        """
        :type n: int
        :rtype: int
        """
        if n == 0:
            return 0
        
        f = [0] * (n + 1)
        f[1] = 1
        for i in range(2, n + 1):
            f[i] = f[i - 1] + f[i - 2]
        return f[n]

动规五部曲:
（1）确定dp数组以及下标
dp[ i ] 是第 i 个斐波那契数
（2）递推公式
dp[ i ] = de[ i-1 ] + dp[ i-2 ]
（3）dp数组初始化
dp[0] = 0, dp[1] = 1
（4）遍历顺序
从前往后
（5）打印dp数组

class Solution(object):
    def fib(self, n):
        """
        :type n: int
        :rtype: int
        """
        if n <= 1:
            return n
        dp = [0,1]
        for i in range(2, n + 1):
            summ = dp[0] + dp[1]
            dp[0] = dp[1]
            dp[1] = summ
        return dp[1]

#递归版本
class Solution(object):
    def fib(self, n):
        """
        :type n: int
        :rtype: int
        """
        if n < 2:
            return n
        return self.fib(n - 1) + self.fib(n - 2)

3.70. 爬楼梯

题目链接：70. 爬楼梯
文档讲解： 代码随想录

这道题的关键是想到规律。爬到第一层楼梯有一种方法，爬到第二层楼梯有两种方法，爬到第三层楼梯，只能从第一层爬2步或者从二层爬1步，因此有3种方法。然后就可以想到动态规划。

动规三部曲：
（1）dp数组和下标的含义
dp[ i ]表示爬到第 i 层楼梯有几种方法
（2）递归公式
dp[ i ] = de[ i-1 ] + dp[ i-2 ]
（3）初始化
dp[1] = 1, dp[2] = 2
（4）遍历顺序
从前往后遍历
（5）打印数组
这步是用来验证

class Solution(object):
    def climbStairs(self, n):
        """
        :type n: int
        :rtype: int
        """
        if n < 3:
            return n
        dp = [0] * (n + 1)
        dp[1] = 1
        dp[2] = 2
        for i in range(3, n + 1):
            dp[i] = dp[i - 1] + dp[i - 2]
        return dp[n]

关于dp[0]，题目中明确表明 n 是个正整数，因此dp[0] 是无实际意义的，因此初始化从1、2开始。

4.746. 使用最小花费爬楼梯

题目链接：746. 使用最小花费爬楼梯
文档讲解： 代码随想录

动规五部曲：
（1）确定dp数组和下标
这步是确定dp[ i ]的实际意义，要返回达到楼梯顶部的最低花费。那么，dp[ i ]表示到达第 i 阶台阶所需要的最小花费。
（2）递推关系式
dp[ i ]可以由 dp[i - 1] 跳一步到达，或者 dp[i - 2] 跳两步到达，那么可以得到关系式：dp[ i ] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2])
（3）初始化
题目说可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯，那么则说明 dp[0] = 0，dp[1] = 0
（4）遍历顺序：从前往后
（5）打印数组

class Solution(object):
    def minCostClimbingStairs(self, cost):
        """
        :type cost: List[int]
        :rtype: int
        """
        #题目中说明了cost的长度大于等于2
        dp = [0] * (len(cost) + 1)
        for i in range(2, len(dp)):
            dp[i] = min(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2])
        return dp[len(cost)]