**LeetCode 70. Climbing Stairs

70.Climbing Stairs

题意： 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?
Note: Given n will be a positive integer.
题意：爬n阶楼梯，每次能爬1步或者2步，返回有多少中爬楼梯的不同方式。

我的思路 未通过

我的第一想法： 考虑极限情况，全为1步和全为2步，这样就要分两种情况：n 为奇数；n 位偶数。且若有 1个2 和 n-1个1 ，那么用高中学的排列组合即可算出有多少种情况，然后按照2的个数计算所有情况，然后将其相加。

但这种方法时间复杂度高，LeetCode上没有通过。附上代码

public int climbStairs(int n) {
    int result = 1;
    if(n <= 0) {return 0;}
    if(n % 2 == 0){
        for(int i = 1; i <= n/2; i++){
            result += arrangement(n - i, i);
        }
        return result;
    }
    else {
        for(int i = 1; i <= (n - 1)/2; i++){
            result += arrangement(n - i, i);
        }
        return result;
    }
}
//计算阶乘//
public int factorial(int a){
    int res = 1;
    for(int i = 1; i <= a; i++) {res *= i;}
    return res;
}
//计算排列组合//  
public int arrangement(int m, int n){
    int res = factorial(m) / (factorial(n) * factorial(m - n));
    return res;     
}

后来看答案，才发现自己算法的思想太欠缺。

方法1 用递归的方法暴力破解 未通过

思路：

我们用 climbStairs(i,n) 代表当前站在第 i 个台阶上，要去第 n 个台阶上。
那么原问题就可以看作 climbStairs(0,n)，那么 climbStairs(0,n) = climbStairs(1,n) + climbStairs(2,n)。
则递推公式为：climbStairs(i,n) = climbStairs(i+1,n) + climbStairs(i+2,n)。

public int climbStairs(int n) {
    climb_Stairs(0, n);
}
public 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^2),递归树的尺寸为 2^n.
空间复杂度：O(n).递归树的深度是 n。

时间复杂度太高，LeetCode上没有通过。
当 n = 5 时，递归树如下图：

方法2 动态规划

思路： 上面的暴力递归中,同一个结果重复运算了很多次，所以采用动态规划的方法，用一个数组来存储已经计算过的值，这样相同的数据只需要计算一次即可，减少了时间复杂度。

public int climbStairs(int n) {
    int memo[] = new int[n + 1];
    return climb_Stairs(0, n, memo);
}
public 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).递归树的尺寸是n。
空间复杂度：O(n).递归树的深度是n。

方法3 斐波那契数列

思路：

到达第i个台阶的方法有两种：
1.从第i-1阶走一步；
2.从第i-2阶走两步；

即:用 dp[i] 来表示到第i阶台阶的方式总数。
则 dp[i] = dp[i-1] + dp[i-2] ;符合斐波那契数列。

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

复杂度分析：

时间复杂度：O(n)。
空间复杂度：O(n)。dp数组的空间。

同样的思想，另一种写法

public int climbStairs(int n) {
    if (n == 1) {
        return 1;
    }
    int first = 1;
    int second = 2;
    for (int i = 3; i <= n; i++) {
        int third = first + second;
        first = second;
        second = third;
    }
    return second;
}

复杂度分析：

时间复杂度：O( n )。
空间复杂度：O( 1 )。使用的空间固定。