假設你正在爬樓梯。需要 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 階

示例 3：
輸入： 4
輸出： 5
解釋： 有五種方法可以爬到樓頂。

1. 1 階 + 1 階 + 1 階+ 1 階
2. 1 階 + 1 階 + 2 階
3. 1 階 + 2 階 + 1 階
4. 2 階 + 1 階 + 1 階
5. 2 階 + 2 階

很明顯，這是一個斐波那契數列，即a[n] = a[n-2] + a[n-1]。n的結果都是由前兩個值相加得到的。

1.閉包實現

假如不考慮空間複雜度的問題，可以將每次結果都快取起來，這樣下次計算就可以省略很多計算步驟。
具體程式碼實現如下：

/**
 * @param {number} n
 * @return {number}
 */
var climbStairs = function(n) {
    let result = {
        0: 1,
        1: 1
    };
    function getData(n){
        if(!result[n]){
           result[n] = getData(n-1) + getData(n-2);//快取結果
        }
        return result[n]
    }
    return getData(n)
} 
 

時間複雜度為O(n)，空間複雜度也為O(n)。優點是結果可以被快取，下次計算的時候效能較好，對於只需進行一次求值的需求來說沒啥區別。缺點是比較佔記憶體。
程式碼如下：

/**
 * @param {number} n
 * @return {number}
 */
var climbStairs = function(n) {
    let result = {
        0: 1,
        1: 1
    };
    function getData(n){
        if(!result[n]){
           result[n] = getData(n-1) + getData(n-2);
        }
        return result[n]
    }
    return getData(n)
} 
 

2. 遍歷實現

程式碼實現如下：

/**
 * @param {number} n
 * @return {number}
 */
var climbStairs = function(n){
    if (n == 0)
        return 0;
    else if (n == 1)
        return 1;
    else{
        let one = 0,
            two = 1,
            i = 0, 
            ret;
        for(; i < n; i++){
            ret = one + two;
            one = two;
            two = ret;
        }
    return ret;
    }
};

思路是，傳入n的值，從0開始計算0-n的值，每次計算的時候將n-1和n-2的值都存起來給下次計算使用。
優點：時間複雜度O(n)，空間複雜度為O(1)，比用閉包思路節省了不少記憶體空間