爬樓梯：經典動態規划+遞歸法

爬樓梯

目錄

• 摘要
• 解決方案
  • 方法 1：暴力法
  • 方法 2：記憶化遞歸
  • 方法 3：動態規划
  • 方法 4: 斐波那契數
  • 方法 5: Binets 方法
  • 方法 6: 斐波那契公式

摘要

假設你正在爬樓梯。需要 n 階你才能到達樓頂。

每次你可以爬 1 或 2 個台階。你有多少種不同的方法可以爬到樓頂呢？

解決方案

---

方法 1：暴力法

算法

在暴力法中，我們將會把所有可能爬的階數進行組合，也就是 1 和 2 。而在每一步中我們都會繼續調用 \(climbStairs\)這個函數模擬爬 1 階和 2 階的情形，並返回兩個函數的返回值之和。

\[climbStairs(i,n) = climbStairs(i + 1, n) + climbStairs(i + 2, n) \]

其中 \(i\) 定義了當前階數，而 \(n\) 定義了目標階數。

class Solution {
public:
    int climbStairs(int n) {
        return climb_Stairs(0,n);
    }
    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)\)。樹形遞歸的大小為 \(2^n\) 。

  在 \(n=5\) 時的遞歸樹將是這樣的：

空間復雜度：\(O(n)\)。遞歸樹的深度可以達到 \(n\) 。

方法 2：記憶化遞歸

算法

在上一種方法中，我們計算每一步的結果時出現了冗余。另一種思路是，我們可以把每一步的結果存儲在 \(memo\) 數組之中，每當函數再次被調用，我們就直接從 \(memo\)數組返回結果。

在 \(memo\) 數組的幫助下，我們得到了一個修復的遞歸樹，其大小減少到 \(n\) 。

class Solution {
public:
    int climbStairs(int n) {
        int memo[n+1];
        return climb_Stairs(0,n,meno);
    }
    int climb_Stairs(int i ,int n,int meno[]){
        if(i > n)return 0;
        if(i == n)return 1;
        if(meno[i] > 0)return meno[i];
        meno = climb_Stairs(i+1,n,meno) + climb_Stairs(i+2,n,meno);
        return meno[i];
    }
};

復雜度分析

• 時間復雜度：\(O(n)\)。樹形遞歸的大小可以達到 \(n\)。
• 空間復雜度：\(O(n)\) 。遞歸樹的深度可以達到 \(n\) 。

方法 3：動態規划

算法

不難發現，這個問題可以被分解為一些包含最優子結構的子問題，即它的最優解可以從其子問題的最優解來有效地構建，我們可以使用動態規划來解決這一問題。

第 ii 階可以由以下兩種方法得到：

1. 在第$ (i-1)$階后向上爬一階。
2. 在第 \((i-2)\)階后向上爬 $2 $階。

所以到達第 ii 階的方法總數就是到第$ (i-1)$ 階和第 \((i-2)\)階的方法數之和。

令$ dp[i]$ 表示能到達第 \(i\)階的方法總數：

\[dp[i]=dp[i-1]+dp[i-2] \]

代碼：

class Solution {
public:
    int climbStairs(int n) {
        if(n <= 3)return n;
        int dp[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)\)，單循環到\(n\) 。
• 空間復雜度：\(O(n)\)。\(dp\)數組用了 \(n\) 的空間。

方法 4: 斐波那契數

算法

在上述方法中，我們使用 \(dp\) 數組，其中 \(dp[i]=dp[i-1]+dp[i-2]\)。可以很容易通過分析得出 \(dp[i]\) 其實就是第$ i$個斐波那契數。

\[Fib(n)=Fib(n-1)+Fib(n-2) \]

現在我們必須找出以 \(1\) 和 \(2\) 作為第一項和第二項的斐波那契數列中的第 \(n\) 個數，也就是說 \(Fib(1)=1\) 且 \(Fib(2)=2\)。

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)\)。單循環到 \(n\)，需要計算第 \(n\) 個斐波那契數。
• 空間復雜度：\(O(1)\)。使用常量級空間。

方法 5: Binets 方法

算法

這里有一種有趣的解法，它使用矩陣乘法來得到第 nn 個斐波那契數。矩陣形式如下：

我們需要為我們的問題做的唯一改動就是將斐波那契數列的初始項修改為 2 和 1 來代替原來的 1 和 0 。或者，另一種方法是使用相同的初始矩陣 \(Q\)並使用 \(result = Q^{n}[0,0]\) 得出最后結果。發生這種情況的原因是我們必須使用原斐波那契數列的第 2 項和第 3 項作為初始項。

 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))\)。遍歷$ log(n)$ 位。
• 空間復雜度：\(O(1)\)。使用常量級空間。

這里的時間復雜度證明比較復雜，這里就不討論了

方法 6: 斐波那契公式

算法

我們可以使用這一公式來找出第 \(n\) 個斐波那契數：

\[F_n = 1/\sqrt{5}\left[ \left(\frac{1+\sqrt{5}}{2}\right)^{n} - \left(\frac{1-\sqrt{5}}{2}\right)^{n} \right] \]

class Solution {
public:
    int climbStairs(int n) {
        double sqrt5=sqrt(5);
        double fibn=pow((1+sqrt5)/2,n+1)-pow((1-sqrt5)/2,n+1);
        return (int)(fibn/sqrt5);
    }
};