leetcode---------爬楼梯

题目：

you are climbing a stair case. It takes n steps to reach to the top.

Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?

Input: 3
Output: 3
Explanation: There are three ways to climb to the top.
1. 1 step + 1 step + 1 step
2. 1 step + 2 steps
3. 2 steps + 1 step

思路：

这一题，我刚开始想的是，这不就是递归嘛？上一个步伐 j ，肯定是 j -1 和 j - 2 所有不同的路加起来；

class Solution {
public:
    int climbStairs(int n) {
        if(n==0)    return 1;
        if(n<0)    return 0;
        int one=climbStairs(n-1);
        int two=climbStairs(n-2);
        return one+two;
        
    }
};

很明显，超过时间限制；

时间复杂度为：

很明显，这是一个二叉树一样的递归，树的高度为 n；则满二叉树所有节点 为-1；

所以此时间复杂度为;

空间复杂度为，树的高度为n；所以递归的深度为n；

因为很多次递归都重复计算了，比如32 ，下面要计算 31 和 30 ，但 31 下面又要计算 30 ；

下面我就想能不能进行记忆化递归呢？没想到，-----看了别人的代码，感觉应该是可以做到的，我当时想前一次计算的数，后一次再次计算，那前一次的值已经计算完毕了嘛？没有咋办；因为是一直往下递归，所以上一次的值，下一次再次遇到肯定是计算完毕了

int climbStairs(int n) {
        int memo[n] = {0};
        return climb_Stairs(0, n, memo);
    }
    int climb_Stairs(int i, int n, int memo[]) {
        if (i > n) {
            return 0;
        }
        if (i == n) {
            return 1;
        }
        if (memo[i] > 0) {
            return memo[i];
        }
        memo[i] = climb_Stairs(i + 1, n, memo) + climb_Stairs(i + 2, n, memo);
        return memo[i];
    }
}

记忆化搜索，保证每一个节点都只算一次，所以时间复杂度为O(n);

空间复杂度为O(n);递归的深度为n；

我没想到记忆化搜索，于是，我想起了，这是一个动态规划；

于是我列出了状态方程：

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

因为从上往下的话，你并不知道下面是多少，比如dp[ 33 ]=dp[ 32 ]+dp[ 30 ];但是dp[ 32 ]还未计算，所以从上往下是行不通的；

但是自底向上是知道的，因为dp[0]=1;dp[1]=1;所以dp[2]=dp[1]+d[0];  dp[3]=dp[2]+dp[1];

因此只要这个状态方程摆上，每个节点也是只需要计算一次的，

等我做完，看了别人的讲解，才知道这是斐波那契数列

时间复杂度为O(n);

空间复杂度为O(n);

class Solution {
public:
    int climbStairs(int n) {
        int dp[n+1]={0};
        dp[0]=1;
        dp[1]=1;
        int i=2;
        while(i<n+1){
            dp[i]=dp[i-1]+dp[i-2];
            ++i;
        }
        return dp[n];


}