leetcode | python | 爬楼梯

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

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

注意：给定 n 是一个正整数。

示例 1：

输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。
1.  1 阶 + 1 阶
2.  2 阶

示例 2：

输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。
1.  1 阶 + 1 阶 + 1 阶
2.  1 阶 + 2 阶
3.  2 阶 + 1 阶

---

solution 1 递归超时

class Solution:
    def climbStairs(self, n: int) -> int:
            if n==1:
                return 1
            elif n==2:
                return 2
            else:
                return self.climbStairs(n-2) + self.climbStairs(n-1)

时间复杂度：O(2^n)。树形递归的大小为 2^n

空间复杂度：O(n)。递归树的深度可以达到 n。 

solution 2 动态规划

第 ii 阶可以由以下两种方法得到：

1. 在第 (i-1)(i−1) 阶后向上爬一阶。

2. 在第 (i-2)(i−2) 阶后向上爬 22 阶。

所以到达第 ii 阶的方法总数就是到第 (i-1)(i−1) 阶和第 (i-2)(i−2) 阶的方法数之和。

令 dp[i]dp[i] 表示能到达第 ii 阶的方法总数：

dp[i]=dp[i-1]+dp[i-2]dp[i]=dp[i−1]+dp[i−2]

class Solution:
    def climbStairs(self, n: int) -> int:
            if n==1:
                return 1
            
            dp = [None]*(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]

• 时间复杂度：O(n)，单循环到 n 。

• 空间复杂度：O(n)。dp 数组用了 n 的空间。 

执行用时 : 52 ms, 在Climbing Stairs的Python3提交中击败了74.10% 的用户

内存消耗 : 13 MB, 在Climbing Stairs的Python3提交中击败了93.69% 的用户

solution 3 斐波那契数列

再往下想一步就可以把空间复杂度降低了哎

可以很容易通过分析得出 dp[i]dp[i] 其实就是第 ii 个斐波那契数。

Fib(n)=Fib(n-1)+Fib(n-2)Fib(n)=Fib(n−1)+Fib(n−2)

class Solution:
    def climbStairs(self, n: int) -> int:
            if n==1:
                return 1
            if n==2:
                return 2
            
            first = 1
            second = 2        
            
            for i in range(3,n+1):
                re = first+second
                first = second
                second = re
                                
            return re

执行用时 : 84 ms, 在Climbing Stairs的Python3提交中击败了6.40% 的用户

内存消耗 : 13 MB, 在Climbing Stairs的Python3提交中击败了95.20% 的用户

• 时间复杂度：O(n)。单循环到 n，需要计算第 n 个斐波那契数。

• 空间复杂度：O(1)。使用常量级空间。