【LeetCode】70. 爬楼梯（同 剑指 Offer 10- II）

一、题目

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意： 给定 n 是一个正整数。

示例 1：

输入： 2
输出： 2
解释： 有两种方法可以爬到楼顶。
1.  1 阶 + 1 阶
2.  2 阶

示例 2：

输入： 3
输出： 3
解释： 有三种方法可以爬到楼顶。
1.  1 阶 + 1 阶 + 1 阶
2.  1 阶 + 2 阶
3.  2 阶 + 1 阶

二、解决

1、递归

思路：

对于第n阶，可以从n-1阶或n-2阶跳上来，由此可以推出：$$F(n)=F(n-1)+F(n-2)$$

使用简单递归实现最简单，但超出时间限制。

代码：

class Solution {
    public int climbStairs(int n) {
        return n<=2 ? n : climbStairs(n-1) + climbStairs(n-2);
    }
}

时间复杂度： $O(2^n)$
空间复杂度： $O(n)$

2、递归+记忆化

思路：

简单递归中有大量重复计算，所以可以缓存加速运算。

记忆化前后计算过程对比：

代码：

class Solution {
    public int climbStairs(int n) {
        Integer[] memo = new Integer[n+1];
        return dfs(n, memo);
    }
    private int dfs(int i, Integer[] memo) {
        if (i <= 3) return i;
        if (memo[i] != null) return memo[i];
        return memo[i] = dfs(i-1, memo) + dfs(i-2, memo);
    }
}

时间复杂度： $O(n)$
空间复杂度： $O(n)$

3、动态规划

版本1

思路：
上面已经得出$dp[i]=dp[i-1]+dp[i-2]$，所以用下面方式编程实现。
代码：

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)

版本2

思路： 同上，这里只是复用了中间的变量，降低了空间复杂度。
代码：

class Solution {
    public int climbStairs(int n) {
        int first = 1, second = 2, sum = 0;
        for (int i = 1; i < n; i++) {
            sum = first + second;
            first = second;
            second = sum;
        }
        return first;
    }
}

时间复杂度： O(n)
空间复杂度： O(1)

4、矩阵快速幂

思路：

代码：

public class Solution {
   public int climbStairs(int n) {
       int[][] q = {{0, 1}, {1, 1}};
       int[][] res = pow(q, n);
       return res[1][1];
   }
   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;
   }
}

解释：上面代码中multiply含义与下面等价。

时间复杂度： O(logn)
空间复杂度： O(1)

5、通项公式

思路：

关于线性代数对角化的知识都忘了，这里先记下关键步骤，有需要再深入。
Binet’s Formula推导过程：

代码：

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(logn)
空间复杂度： O(1)

三、参考

1、爬楼梯
2、Basically it’s a fibonacci.
3、3-4 short lines in every language