python3__leecode/0070.爬楼梯

---

一、刷题内容

原题链接

https://leetcode-cn.com/problems/climbing-stairs/

内容描述

假设你正在爬楼梯。需要 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 阶

PS:其实这是个斐波那契题了

二、解题方案

1.方法一：动态规划记忆法

memorize，top-down，自顶向下的假定前面楼梯已经走完，考虑最后一步走一个或是两个台阶，将重复计算的值记录下来。

class Solution:
    dp = {1: 1, 2: 2}
    def climbStairs(self, n: int) -> int:
        if n in self.dp:
            return self.dp[n]
        else:
            self.dp[n] = self.climbStairs(n - 1) + self.climbStairs(n - 2)
            return self.dp[n]

2.方法二：动态规划制表法

tabulation，bottom up，自底向上的建立一个表，返回表的最新记录

class Solution:
    def climbStairs(self, n: int) -> int:
        # 动态规划 制表法，tabulation
        dp = [1, 2]
        for i in range(2, n):
            dp.append(dp[i - 1] + dp[i - 2])
        return dp[n - 1]

3.方法三：制表法

其实每次用到就最后两个值，所以可以只存最后两个数，可以节省空间。

class Solution:
    def climbStairs(self, n: int) -> int:
        dp = [1, 2, 3]
        if n < 3:  # 如果走的是一阶或者两阶，直接返回
            return dp[n - 1]

        for i in range(n - 2):  # 这边的边界判断很有意思，给的好的话，可以少多两次循环
            dp[2] = dp[0] + dp[1]
            dp[0], dp[1] = dp[1], dp[2]
        return dp[2]

class Solution:
    def climbStairs(self, n: int) -> int:
        f0 = 1
        f1 = 1
        for i in range(n-1):
            f0, f1 = f1, f0 + f1
        return f1

4.方法四：公式法

import math
class Solution:
    def climbStairs(self, n):
        x = n + 1
        a = math.sqrt(5)
        b = 1 / a * (pow((1 + a) / 2, x) - pow((1 - a) / 2, x))
        return int(b)

5.方法五：生成器

class Solution:
    def fib(self):
        a, b = 0, 1
        while True:
            a, b = b, a + b
            yield b
            
    def climbStairs(self, n: int) -> int:
        fib = self.fib()
        while n:
            ret = next(fib)
            n -= 1
        return ret