爬楼梯

1. 问题描述：

假设你正在爬楼梯，需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？（注意：给定 n 是一个正整数）

示例 1：
输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶
（ 1 阶 + 1 阶 或 2 阶）

示例 2：
输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶
（1 阶 + 1 阶 + 1 阶 或 1 阶 + 2 阶 或 2 阶 + 1 阶）

2. 问题分析：

1. 方法一（递归的方法实现）：首先，我们知道当 n = 1 时，只有一种方法可以到顶；当 n = 2 时，有两种方法可以到顶；当 n 很大时，我们就不能判断出到底有多少种方法。但我们可以用递归方法将问题一步步分解成很小的问题。我们可以知道最后一步可以爬一阶台阶或爬两阶台阶，故爬 n 阶台阶可以分解成 fun(n) = fun(n - 1) + fun(n - 2)，以此类推，直到 n = 1 或 n = 2，问题求解完毕（递归的时间复杂度较大）。
2. 方法二（for 循环实现）：当 n = 1 时，只有一种方法可以到顶；当 n = 2 时，有两种方法可以到顶；当 n >= 3 时，爬 n 阶台阶等于爬 n - 1 阶台阶与爬 n - 2 阶台阶之和（与斐波那契数列的求法一致）。
3. 方法三（动态规划）：此方法的思想与方法二类似，只是将爬楼梯的方法种数存放在数组里，一步步推算出爬 n 阶楼梯所要的方法种数。

3. 代码实现：

1. 方法一的代码实现：

class Solution {
    public int climbStairs(int n) {
        return fun(n);
    }
    private int fun(int n) {
         if(n == 1) {
             return 1;
         } else if(n == 2) {
             return 2;
         } else {
             return fun(n - 1) + fun(n - 2);
         }
     }
}

2. 方法二的代码实现：

class Solution {
    public int climbStairs(int n) {
        int a = 1, b = 1;
        for(int i = 1; i < n; i++) {
            int temp = b;
            b= b + a;	//将a+b赋值给b
            a = temp;	//将原来的b赋值给a
        }
        return b;
    }
}

3. 方法三的代码实现：

class Solution {
    public int climbStairs(int n) {
        if(n == 1)  return 1;
        if(n == 2)  return 2;
        int count[] = new int [n + 1];
        count[1] = 1;
        count[2] = 2;
        for( int i = 3; i <= n; i++) {
            count[i] = count[i - 1] + count[i - 2];
        }
        return count[n];
    }
}

小熊的分享到此结束！！！