假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

记忆递归

class Solution(object):
    def climbStairs(self, n):
        # """
        # :type n: int
        # :rtype: int
        # """
        # if n ==0 or n ==1:
        #     return 1
        # return self.climbStairs(n-1)+self.climbStairs(n-2)

        # 记忆化递归
        def dfs(i, memo):
            if i==0 or i ==1:
                return 1
            if memo[i] == -1:
                memo[i] = dfs(i-1, memo)+dfs(i-2,memo)
            return memo[i]
        return dfs(n, [-1]*(n+1))
solution = Solution()
n = solution.climbStairs(8)
print(n)

1. climbStairs 函数是外部调用的接口，传入参数 n 表示楼梯的阶数。这个函数内部定义了一个嵌套函数 dfs 来执行递归。
2. dfs 函数是一个递归函数，用于计算爬到第 i 阶楼梯的方式数量。递归的基本情况是当 i 等于 0 或 1 时，只有一种爬法，即不爬或者爬一阶。如果 memo[i] 不等于 -1，说明已经计算过，直接返回保存的结果；否则，计算 dfs(i - 1, memo) + dfs(i - 2, memo)，即爬到当前阶数的方式数量，并将结果保存在 memo[i] 中。
3. 在 climbStairs 函数内部，初始化一个长度为 n + 1 的数组 memo，用于保存计算结果。初始时，数组的每个元素都设置为 -1，表示尚未计算。然后调用 dfs(n, memo)，从顶层开始计算爬到第 n 阶楼梯的方式数量。

动态规划

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

1. dp 是一个长度为 n + 1 的数组，用于保存到达每个阶梯的方式数量。数组的索引表示阶梯的编号，数组的值表示到达该阶梯的方式数量。
2. 初始化 dp[0] 和 dp[1] 分别为 1，因为到达第 0 阶和第 1 阶的方式只有一种，就是不走或者走一步。
3. 使用循环从第 2 阶开始，依次计算到达每个阶梯的方式数量。对于每个阶梯 i，它的方式数量等于前两个阶梯的方式数量之和，即 dp[i] = dp[i - 1] + dp[i - 2]。
4. 最终返回 dp[-1]，即到达第 n 阶的方式数量。