算法:Climbing Stairs(爬楼梯) 6种解法
说明
算法：Climbing Stairs(爬楼梯)
LeetCode地址：https://leetcode.com/problems/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.
Example 1:
Input: 2
Output: 2
Explanation: There are two ways to climb to the top.
1. 1 step + 1 step
2. 2 steps
Example 2:
Input: 3
Output: 3
Explanation: There are three ways to climb to the top.
3. 1 step + 1 step + 1 step
4. 1 step + 2 steps
5. 2 steps + 1 step
解题思路1 - 递归
爬楼梯直接思路递归法，登顶的最后一步有两种走法，也就是1步，后者2步。
所以可以得出公式f(n) = f(n-1) + f(n-2).
注意初始条件
- f(1) = 1;
- f(2) = 2;
复杂度分析，时间复杂度为2^n。
因为有重复的数据多次计算，比如f(3), 每个大于3的都要重新计算一次。
递归函数还有个弊端，需要担心函数调用栈溢出。
代码实现1
public class ClimbingStairs {
public static int climbStairsWithRecursion(int n) {
if (n == 1) {
return 1;
} else if (n == 2) {
return 2;
} else {
return climbStairsWithRecursion(n - 1) + climbStairsWithRecursion(n - 2);
}
}
}
代码执行效率1
Runtime: 7107 ms, faster than 10.50% of Java online submissions for Climbing Stairs.
Memory Usage: 36.4 MB, less than 27.61% of Java online submissions for Climbing Stairs.
解题思路2 - 递归加缓存
递归执行效率太低真实原因，是因为数据重复计算，用数组memoryArray存储已经计算过得数据。
时间复杂度降低为O(n), 内存复杂度为O(n) .
代码实现2
public class ClimbingStairs {
public static int climbStairsWithRecursionMemory(int n) {
int[] memoryArray = new int[n + 1];
return subClimbStairsWithRecursionMemory(n - 1, memoryArray) + subClimbStairsWithRecursionMemory(n - 2, memoryArray);
}
public static int subClimbStairsWithRecursionMemory(int n, int[] memoryArray) {
if (n == 1) {
return 1;
} else if (n == 2) {
return 2;
} else {
if (memoryArray[n] > 0) {
return memoryArray[n];
}
memoryArray[n] = subClimbStairsWithRecursionMemory(n - 1, memoryArray) + subClimbStairsWithRecursionMemory(n - 2, memoryArray);
return memoryArray[n];
}
}
}
代码执行效率 2
Runtime: 2 ms, faster than 90.23% of Java online submissions for Climbing Stairs.
Memory Usage: 36.5 MB, less than 6.57% of Java online submissions for Climbing Stairs.
解题思路3 - 动态规划
担心递归会有函数调用指针栈溢出风险，既然有子函数解决问题方案，动态规划呼之即出。
递推公式：f(n) = f(n-1) + f(n-2)
时间复杂度降低为O(n), 内存复杂度为O(n) .
代码实现3
public class ClimbingStairs {
public static int climbStairsWithDynamic(int n) {
if (n == 1) {
return 1;
}
int dynamicArray[] = new int[n + 1];
dynamicArray[1] = 1;
dynamicArray[2] = 2;
for (int i = 3; i <= n; i++) {
dynamicArray[i] = dynamicArray[i - 1] + dynamicArray[i - 2];
}
return dynamicArray[n];
}
}
解题思路4 - Fibonacci
内存占用太高，公式很熟悉Fibonacci， 直接用3个变量就好，first, second, third。
递推公式：f(n) = f(n-1) + f(n-2)
时间复杂度降低为O(n), 内存复杂度为O(1) .
代码实现4
public class ClimbingStairs {
public static int climbStairsWithFibonacci(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;
}
}
解题思路5 - Fibonacci优化变量
内存占用太高，公式很熟悉Fibonacci， 变量是否还可以不用临时变量third呢，是可以的。
递推公式：f(n) = f(n-1) + f(n-2)
时间复杂度降低为O(n), 内存复杂度为O(1) .
代码实现5
public class ClimbingStairs {
public static int climbStairs(int n) {
int a = 1, b = 1;
while (--n > 0) {
b = b + a;
a = b - a;
}
return b;
}
}
代码执行效率 5
Runtime: 1 ms, faster than 100.00% of Java online submissions for Climbing Stairs.
Memory Usage: 36.6 MB, less than 5.01% of Java online submissions for Climbing Stairs.
解题思路6 - Fibonacci Formula
实际上时间复杂度O(n)不是最优。用公式的时间复杂度为 : O(log(n)). 因为开根号方法pow用时间log(n) .
空间复杂度O(1).
代码实现6
public class ClimbingStairs {
public static int climbStairsWithFibonacciFormula(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);
}
}
代码执行效率 6
Runtime: 1 ms, faster than 100.00% of Java online submissions for Climbing Stairs.
Memory Usage: 36.4 MB, less than 24.93% of Java online submissions for Climbing Stairs.
测试
public static void main(String[] args) {
int n1 = 2;
System.out.println("input: " + n1 + " climbStairs: " + climbStairs(n1));
int n2 = 3;
System.out.println("input: " + n2 + " climbStairs: " + climbStairs(n2));
int n3 = 20;
System.out.println("input: " + n3 + " climbStairs: " + climbStairs(n3));
System.out.println("input: " + n3 + " climbStairsWithRecursion: " + climbStairsWithRecursion(n3));
System.out.println("input: " + n3 + " climbStairsWithRecursionMemory: " + climbStairsWithRecursionMemory(n3));
System.out.println("input: " + n3 + " climbStairsWithDynamic: " + climbStairsWithDynamic(n3));
System.out.println("input: " + n3 + " climbStairsWithFibonacci: " + climbStairsWithFibonacci(n3));
System.out.println("input: " + n3 + " climbStairsWithFibonacciFormula: " + climbStairsWithFibonacciFormula(n3));
}
结果
input: 2 climbStairs: 2
input: 3 climbStairs: 3
input: 20 climbStairs: 10946
input: 20 climbStairsWithRecursion: 10946
input: 20 climbStairsWithRecursionMemory: 10946
input: 20 climbStairsWithDynamic: 10946
input: 20 climbStairsWithFibonacci: 10946
input: 20 climbStairsWithFibonacciFormula: 10946
总结
爬楼梯由最初的递归解法，
降低时间复杂度用了缓存优化，
降低方法调用栈溢出用了动态规划，
降低空间复杂度用了斐波那系数Fibonacci，
最后竟然有O(log(n))的时间复杂度优化方法Fibonacci Formula。
前人的经验，我们的阶梯。
代码下载：
https://github.com/zgpeace/awesome-java-leetcode/blob/master/code/LeetCode/src/ClimbingStairs.java
参考：
https://leetcode.com/problems/climbing-stairs/solution/