**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_Sta
4000
irs(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
;
}

复杂度分析：

时间复杂度：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 )。使用的空间固定。