每日一題——爬樓梯

菜雞每日一題系列打卡70天

每天一道算法題目

小夥伴們一起留言打卡

堅持就是勝利，我們一起努力！

題目描述(引自LeetCode)

假設你正在爬樓梯。需要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 階

題目分析

這是一道經典的動態規劃題目，但不是一道非動態規劃不可的題目。在本題中，菜雞將嘗試使用六種解法進行解答。

其中，第一種解法(普通遞歸)由於時間複雜度太高，在LeetCode提交中會TLE。其餘五種解法均可AC。

Talk is cheap， show you the code！

代碼實現

// 普通遞歸，包含大量重複計算
// 時間複雜度爲O(2^n)，空間複雜度爲O(n)
class Solution {
    public int climbStairs(int n) {
        if (n < 4) return n;
        return climbStairs(n - 1) + climbStairs(n - 2);
    }
}

// 記憶化遞歸，通過數組來保存中間計算的結果
// 時間複雜度爲O(n)，空間複雜度爲O(n)
class Solution {
    public int climbStairs(int n) {
        if (n < 4) return n;
        int[] tmp = new int[n];
        tmp[0] = 1;
        tmp[1] = 2;
        return getResult(n - 1, tmp);
    }


    private int getResult(int n, int[] tmp) {
        if (tmp[n] > 0) return tmp[n];
        tmp[n] = getResult(n - 1, tmp) + getResult(n - 2, tmp);
        return tmp[n];
    }
}

// 動態規劃
// 時間複雜度爲O(n)，空間複雜度爲O(n)
class Solution {
    public int climbStairs(int n) {
        if (n < 4) return n;
        int[] dp = new int[n];
        dp[0] = 1;
        dp[1] = 2;
        for (int i = 2; i < n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n - 1];
    }
}

// 斐波那契數列
// 時間複雜度爲O(n)，空間複雜度爲O(1)
class Solution {
    public int climbStairs(int n) {
        if (n < 4) return n;
        int a = 2, b = 3;
        for (int i = 4; i <= n; i++) {
            int tmp = a + b;
            a = b;
            b = tmp;
        }
        return b;
    }
}

// 斐波那契數列通項公式的矩陣形式
// 利用快速冪的原理，時間複雜度爲O(logn)，空間複雜度爲O(1)
public class Solution {
   public int climbStairs(int n) {
       int[][] a = {{1, 1}, {1, 0}};
       int[][] b = {{1, 0}, {0, 1}};
       while (n > 0) {
           if ((n & 1) == 1) b = multi(b, a);
           a = multi(a, a);
           n >>= 1;
       }
       return b[0][0];
   }
   
   public int[][] multi(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;
   }
}

// Binet's Formula
// 時間複雜度爲O(logn)，空間複雜度爲O(1)
public class Solution {
    public int climbStairs(int n) {
        return (int)((Math.pow((1 + Math.sqrt(5)) / 2, n + 1) - Math.pow((1 - Math.sqrt(5)) / 2, n + 1)) / Math.sqrt(5));
    }
}

代碼分析

上述六種解法的順序，也一定程度上展示出了逐步優化的過程。具體的時間複雜度與空間複雜度均已寫在每種解法的開始，在此就不再贅述。

執行結果