摘要
假设你正在爬楼梯，需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶，你有多少种不同的方法可以爬到楼顶呢？
解决方案
方法一：暴力法
算法
在暴力法中，我们将会把所有可能爬的阶数进行组合，也就是 1 和 2 。而在每一步中我们都会继续调用 climbStairsclimbStairs 这个函数模拟爬 11 阶和 22 阶的情形，并返回两个函数的返回值之和。
climbStairs(i,n)=(i + 1, n) + climbStairs(i + 2, n)
climbStairs(i,n)=(i+1,n)+climbStairs(i+2,n)
其中 ii 定义了当前阶数，而 nn 定义了目标阶数。
Java
public class Solution {
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(2^n)O(2
n
)，树形递归的大小为 2^n2
n
。
在 n = 5 时的递归树将是这样的：
空间复杂度：O(n)O(n)，递归树的深度可以达到 nn 。
方法二：记忆化递归
算法
在上一种方法中，我们计算每一步的结果时出现了冗余。另一种思路是，我们可以把每一步的结果存储在 memomemo 数组之中，每当函数再次被调用，我们就直接从 memomemo 数组返回结果。
在 memomemo 数组的帮助下，我们得到了一个修复的递归树，其大小减少到 nn。
Java
public class Solution {
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)O(n)，树形递归的大小可以达到 nn。
空间复杂度：O(n)O(n)，递归树的深度可以达到 nn。
方法三：动态规划
算法
不难发现，这个问题可以被分解为一些包含最优子结构的子问题，即它的最优解可以从其子问题的最优解来有效地构建，我们可以使用动态规划来解决这一问题。
第 ii 阶可以由以下两种方法得到：
在第 (i-1)(i−1) 阶后向上爬一阶。
在第 (i-2)(i−2) 阶后向上爬 22 阶。
所以到达第 ii 阶的方法总数就是到第 (i-1)(i−1) 阶和第 (i-2)(i−2) 阶的方法数之和。
令 dp[i]dp[i] 表示能到达第 ii 阶的方法总数：
dp[i]=dp[i-1]+dp[i-2]
dp[i]=dp[i−1]+dp[i−2]
示例：
7 / 7
Java
public class Solution {
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)，单循环到 nn 。
空间复杂度：O(n)O(n)，dpdp 数组用了 nn 的空间。
方法四：斐波那契数
算法
在上述方法中，我们使用 dpdp 数组，其中 dp[i]=dp[i-1]+dp[i-2]dp[i]=dp[i−1]+dp[i−2]。可以很容易通过分析得出 dp[i]dp[i] 其实就是第 ii 个斐波那契数。
Fib(n)=Fib(n-1)+Fib(n-2)
Fib(n)=Fib(n−1)+Fib(n−2)
现在我们必须找出以 11 和 22 作为第一项和第二项的斐波那契数列中的第 nn 个数，也就是说 Fib(1)=1Fib(1)=1 且 Fib(2)=2Fib(2)=2。
Java
public class Solution {
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(n)，单循环到 nn，需要计算第 nn 个斐波那契数。
空间复杂度：O(1)O(1)，使用常量级空间。
方法五：Binets 方法
算法
这里有一种有趣的解法，它使用矩阵乘法来得到第 nn 个斐波那契数。矩阵形式如下：
我们需要为我们的问题做的唯一改动就是将斐波那契数列的初始项修改为 2 和 1 来代替原来的 1 和 0 。或者，另一种方法是使用相同的初始矩阵 QQ 并使用 result = Q^{n}[0,0]result=Q
n
[0,0] 得出最后结果。发生这种情况的原因是我们必须使用原斐波那契数列的第 2 项和第 3 项作为初始项。
Java
public class Solution {
public int climbStairs(int n) {
int[][] q = {{1, 1}, {1, 0}};
int[][] res = pow(q, n);
return res[0][0];
}
public int[][] pow(int[][] a, int n) {
int[][] ret = {{1, 0}, {0, 1}};
while (n > 0) {
if ((n & 1) == 1) {
ret = multiply(ret, a);
}
n >>= 1;
a = multiply(a, a);
}
return ret;
}
public int[][] multiply(int[][] a, int[][] b) {
int[][] c = new int[2][2];
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
c[i][j] = a[i][0] * b[0][j] + a[i][1] * b[1][j];
}
}
return c;
}
}
复杂度分析
时间复杂度：O(log(n))O(log(n))，遍历 log(n)log(n) 位。
空间复杂度：O(1)O(1)，使用常量级空间。
对时间复杂度的证明：
方法六：斐波那契公式
算法
解上述等式，我们得到：
A = left(frac{1+sqrt{5}}{2sqrt{5}} ight), B = left(frac{1-sqrt{5}}{2sqrt{5}} ight)
Java
public class Solution {
public int climbStairs(int n) {
double sqrt5=Math.sqrt(5);
double fibn=Math.pow((1+sqrt5)/2,n+1)-Math.pow((1-sqrt5)/2,n+1);
return (int)(fibn/sqrt5);
}
}
复杂度分析
时间复杂度：O(log(n))O(log(n))，powpow 方法将会用去 log(n)log(n) 的时间。
空间复杂度：O(1)O(1)，使用常量级空间。
public int climbStairs(int n) {
int result = 0;
switch(n){
case 1: result = 1; break;
case 2: result = 2; break;
case 3: result = 3; break;
case 4: result = 5; break;
case 5: result = 8; break;
case 6: result = 13; break;
case 7: result = 21; break;
case 8: result = 34; break;
case 9: result = 55; break;
case 10: result = 89; break;
case 11: result = 144; break;
case 12: result = 233; break;
case 13: result = 377; break;
case 14: result = 610; break;
case 15: result = 987; break;
case 16: result = 1597; break;
case 17: result = 2584; break;
case 18: result = 4181; break;
case 19: result = 6765; break;
case 20: result = 10946; break;
case 21: result = 17711; break;
case 22: result = 28657; break;
case 23: result = 46368; break;
case 24: result = 75025; break;
case 25: result = 121393; break;
case 26: result = 196418; break;
case 27: result = 317811; break;
case 28: result = 514229; break;
case 29: result = 832040; break;
case 30: result = 1346269; break;
case 31: result = 2178309; break;
case 32: result = 3524578; break;
case 33: result = 5702887; break;
case 34: result = 9227465; break;
case 35: result = 14930352; break;
case 36: result = 24157817; break;
case 37: result = 39088169; break;
case 38: result = 63245986; break;
case 39: result = 102334155; break;
case 40: result = 165580141; break;
case 41: result = 267914296; break;
case 42: result = 433494437; break;
case 43: result = 701408733; break;
case 44: result = 1134903170; break;
case 45: result = 1836311903; break;
}
return result;
}
来自 <https://leetcode-cn.com/problems/climbing-stairs/comments/>