爬楼梯

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

解题思路：
动态规划思想。
自己的求解过程，感觉有点儿像数学中的“归纳法”，先把小规模的解列出来，再归纳出函数。
知道问题规模小的时候的解（函数f(n)，特殊），如n=1、2，然后推理得f(n)=f(n-1)+f(n-2)

Python:
一、
超时

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

二、

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

C++
方法一：
暴力递归，列举出可能的情况。
时间复杂度O(2ⁿ)，空间复杂度O(n).

class Solution {
public:
    int climbStairs(int n) {
        return climb_Stairs(0, n);
    }
    int climb_Stairs(int i, int n){
        if(i>n) return 0;
        if(i==n) return 1;
        return climb_Stairs(i+1, n) + climb_Stairs(i+2, n);
    }
};

方法二
记忆递归
时间复杂度O(n)，空间复杂度O(n)
暴力递归中有许多重叠子问题，将计算过的子问题的解保存起来，可以减小时间复杂度。

class Solution {
public:
    int climbStairs(int n) {
        int mem[n+1];
        memset(mem, 0, sizeof(mem));  //将数组初始化为0
        return climb_Stairs(0, n, mem);
    }
    int climb_Stairs(int i, int n, int mem[]){
        if(i>n) return 0;
        if(i==n) return 1;
        if(mem[i]>0) return mem[i];
        mem[i] = climb_Stairs(i+1, n, mem) + climb_Stairs(i+2, n, mem);
        return mem[i];
    }
};

方法三
动态规划/斐波那契数：
第i阶的解可以由子问题：
（1） 第i-1阶的解，向后爬一阶；
（2） 第i-2阶的解，向后爬两阶；
的和得到。
时间复杂度O(n)，空间复杂度O(1).

class Solution {
public:
    int climbStairs(int n) {
        if(n==1) return 1;
        if(n==2) return 2;
        int a = 1, b =2;   //保存n为1、2的值
        int i = 3;         //n从3开始
        int count = 0;     //最终的返回值
        while(i <= n ){
            count = a + b;
            a = b;
            b = count;
            ++i;
        }
        return count;
    }
};