面試官：你有m個雞蛋，如何用最少的次數測出雞蛋會在哪一層碎？

阿新 • • 發佈：2019-12-31

假設你面前有一棟n層的大樓和m個雞蛋，假設將雞蛋從f層或更高的地方放扔下去，雞蛋才會碎，否則就不會。你需要設計一種策略來確定f的值，求最壞情況下扔雞蛋次數的最小值。

leetcode原題連結

乍一看這道題很抽象，可能有的人一看到這個題目從來沒做過，就懵逼了。其實不用慌張，再花裡胡哨的題目，最後都可以抽象成我們熟悉的資料結構和演演算法去解決。

不限雞蛋

首先，我們從一個簡單的版本開始理解，假如不限制雞蛋個數，即把題目改成n層大樓和無限個雞蛋。那麼這題要怎麼解呢？
第一步就是要充分理解題意，排除題目中的幹擾，建立模型：

在一棟n層的大樓中尋找目標樓層f --> 其實就是在一個1～n的陣列中查詢一個目標數字。

雞蛋碎了就代表樓層過高，否則就代表樓層過低 --> 每次嘗試都能知道當前數字是大了還是小了。

很顯然，這就是一個二分查詢能解決的問題。
扔雞蛋的次數就是二分查詢的比較次數，即 log_2(n+1) 。

限制雞蛋個數

那我們現在再來看限制雞蛋個數情況下，肯定沒法用二分查詢，但是由於求解的是一個最優值，我們自然而然地想到了動態規劃。

四步走

動態規劃的題目，這邊提供一個思路，就是四步走：

問題建模，優化的目標函式是什麼？約束條件是什麼？
劃分子問題（狀態）
列出狀態轉移方程及初值
是否滿足最優子結構性質

建模

這一步非常非常重要，它建立在良好地理解題意的基礎上。其實很多動態規劃的題目都有這樣的特點：

目標是求一個最優值

每一步決策有代價，總代價有一個約束值。

而這道題：

目標函式f(n)：代表在1～n的樓層中找到f層的嘗試次數，我們的目標就是求出f(n)的最優值。
每一步決策的代價：雞蛋可能會碎；總代價的約束值：雞蛋總個數。

劃分子問題

我們知道動態規劃就是多階段決策的過程，最後求解組合最優值。我們先舉一個簡單例子，來理解劃分子問題的思路，看下面這張圖:

問題：求起點集 S1～S5到終點集 T1～T5的最短路徑。

分析這道題：定義子問題dis[i]代表節點i到終點的最短距離，沒有約束條件。然後問題劃分為4個階段：

階段1求出離終點最近的C1~C4節點到終點的最短路徑dis[C1]~dis[C4]

。
階段2求出離終點最近的B2~B5節點到終點的最短路徑dis[B1]~dis[B5]，需要建立在階段1的結果上計算。例如B2節點到終點有兩條路，B2～C1，B2～C2，dis[C1]=2，B2到C1的長度=3；而dis[C2]=3，B2到C2的長度=6，因此dis[B2]=3+dis[B1]=5。
階段3和階段4也是以此類推，最終就求出得到dis[S1]~dis[S5]，得出最小路徑為圖中紅色的兩條。

在這道題中，dis[i]就是劃分出來的子問題，每一步決策都是一個子問題，而且每一個子問題都依賴於以前子問題的計算結果。

因此，在動態規劃中，定義一個合理的子問題非常重要。

而扔雞蛋這道題比上面這道題多了個約束條件，我們把子問題定義為：用i個雞蛋，在j層樓上扔，在最壞情況下確定目標樓層E的最少次數，記為狀態f[i,j]。

列出狀態轉移方程和初值

假如決策是在第k層扔下雞蛋，有兩種結果：

雞蛋碎了，此時e<k，我們只能用i-1個蛋在下面的k-1層繼續尋找e。並且要求最壞情況下的次數最少，這是一個子問題，答案為f[i-1,k-1]，總次數便是f[i-1,k-1]+1。
雞蛋沒碎，此時e>=k，我們繼續用這i個蛋在上面的j-k層尋找E。注意：在k～j層尋找和在1～(j-k)層尋找沒有區別，因為步驟都是一樣的，只不過這(j-k)層在上面罷了，所以就把它看成是對1～(j-k)層的操作。因此答案為f[i,j-k]，次數為f[i,j-k]+1。

初值：當層數為0時，f[i,0]=0，當雞蛋個數為1時，只能從下往上一層層扔，f[1,j]=j。

因為是要最壞情況，所以這兩種情況要取大值：max{f[i-1,j-1]，f[i,j-k]}，又要在所有決策中取最小值，所以動態轉移方程是：

$f(i,j)=min\{max\{f(i-1,k-1),f(i,j-k)\}+1|1<=k<=j\}$

是否滿足最優子結構

得到了狀態轉移方程後，還需要判斷我們的思路是不是正確。能用動態規劃解決的問題必須要滿足一個特性，叫做最優子結構特性。

一個最優決策序列的任何子序列本身一定是相對於子序列的初始和結束狀態的最優決策序列。

這句話是什麼意思呢？舉個例子：f[4,5]表示4個雞蛋、5層樓時的最優解，那它的子問題f[3,4]，得到的解在3個雞蛋、4層樓時也是最優解，它所有的子問題都滿足這個特性。那這就滿足了最優子結構特性。

一個反例

求路徑長度模10 結果最小的路徑

還是像上面那道題一樣，分成四個階段。
按照動態規劃的解法，階段一CT，上面的路2 % 10 = 2，下面的路5 % 10 = 5，選擇上面那條，階段二BC也選擇上面那條，以此類推，最後得出的結果路徑是藍色的這條。

但實際上，真正最優的是紅色的這條路徑20 % 10 = 0。這就是因為不符合最優子結構，對於紅色路徑的子結構CT階段，最優解並不是下面這條邊。

時間複雜度

遞迴樹

假設m=3，n=4，我們來看一下f[3,4]的遞迴樹。

圖中顏色相同的就是一樣的狀態，可以看出，重複的遞迴計算很多，因此我們開設一個陣列result[i,j]用於存放f[i,j]的計算結構，避免重複計算，用空間換時間。

程式碼

class Solution {
    private int[][] result;
    
    public int superEggDrop(int K,int N) {
        result = new int[K + 1][N + 1];

        for (int i = 1; i < K + 1; i++) {
            for (int j = 1; j < N + 1; j++) {
                result[i][j] = -1;
            }
        }

        return dp(K,N);
    }
    

    /**
     * @param i 剩餘雞蛋個數
     * @param j 樓層高度
     * @return
     */
   private int dp(int i,int j) {
        if (result[i][j] != -1) {
            return result[i][j];
        }
        if (i == 1) {
            return j;
        }
        if (j <= 1) {
            return j;
        }

        int min = Integer.MAX_VALUE;
        for (int k = 1; k <= j; k++) {
            int left = dp(i - 1,k - 1);
            result[i - 1][k - 1] = left;

            int right = dp(i,j - k);
            result[i][j - k] = right;

            int res = Math.max(left,right) + 1;
            if (res < min) {
                min = res;
            }
        }
        return min;
    }
    
   private static int log(int x) {
        double r = (Math.log(x) / Math.log(2));
        if ((r == Math.floor(r)) && !Double.isInfinite(r)) {
            return (int) r;
        } else {
            return (int) r + 1;
        }
    }
}
複製程式碼

時間複雜度

動態規劃求時間複雜度的方法是：

時間複雜度 = 狀態總數 * 狀態轉移方程的時間複雜度
複製程式碼

在這道題中，狀態總個數很明顯是m*n，而每個狀態f[i,j]的時間複雜度為 O(j) ， $1 \leq j \leq n$ ，總時間複雜度為 O(mn^2) 。

優化

O(mn^2) 的時間複雜度還是太高了。能不能想辦法優化一下？

優化1

決策樹

首先我們知道，在一個1～n的陣列中，查詢目標數字，最少需要比較 log_2n 次，也就是二分查詢。這個理論可以通過決策樹來證明：
我們使用二叉樹來表示所有的決策，內部節點表示一次扔雞蛋的決策，左子樹表示碎了，右子樹表示沒碎，葉子節點代表E的所有結果。每一條從根節點到葉子節點的路徑對應演演算法求出E之前的所有決策。

內部節點(i,j)，i表示雞蛋個數，j表示在j層樓扔下。

當樓層高度n=5時，E總共有6種情況（n=0代表沒找到），所以葉子節點的個數是n+1個。而我們關心的是樹的高度，即決策的次數。根據二叉樹理論：當樹有n個葉子節點，數的高度至少為 log_2n ，即比較次數在最壞情況下至少需要 log_2n 次，也就是當這顆樹儘量平衡的時候。

換句話說，在給定樓層n的情況下，決策次數的下限是 log_2(n+1) ，這個下限可以通過二分查詢達到，只要雞蛋的數量足夠（就是我們剛才討論的不限雞蛋的情況）。

因此，一旦狀態f[i,j]的雞蛋個數 i>log_2(j+1) ，就不用計算了，直接輸出二分查詢的比較次數即可。

這樣我們的狀態總數就降為 n*log_2(k+1) ，時間複雜度降為 O(n^2 log_2n) 。

程式碼

/**
 * @param i 剩餘雞蛋個數
 * @param j 樓層高度
 * @return
 */
private int dp(int i,int j) {
    if (result[i][j] != -1) {
        return result[i][j];
    }
    if (i == 1) {
        return j;
    }
    if (j <= 1) {
        return j;
    }
    
    //此處剪枝優化
    int lowest = log(j + 1);
    if (i > lowest) {
        return lowest;
    }

    int min = Integer.MAX_VALUE;
    for (int k = 1; k <= j; k++) {
        int left = dp(i - 1,k - 1);
        result[i - 1][k - 1] = left;

        int right = dp(i,j - k);
        result[i][j - k] = right;

        int res = Math.max(left,right) + 1;
        if (res < min) {
            min = res;
        }
    }
    return min;
}
複製程式碼

優化2

優化還未結束，我們嘗試從動態轉移方程的函式性質入手，觀察函式f(i,j)，如下圖：

我們可以發現一個規律，f(i,j)是根據j遞增的單調函式，即f(i,j)>=f(i,j-1)，這個性質是可以用數學歸納法證明的，在這裡不做證明，有興趣的檢視文末參考文獻。

再來看動態轉移方程：

$f(i,j-k)\}+1|1<=k<=j\}$

由於 f(i,j) 具有單調性，因此 f(i-1,k-1) 是根據k遞增的函式， f(i,j-k) 是根據k遞減的函式。

分別畫出這兩個函式的影象：

影象1： f(i-1,k-1)
影象2： f(i,j-k)
影象3： $max\{f(i-1,j-k)\}+1$ ，當k=kbest時，f達到最小值，我們的目標就是找到kbest的值。

對於這個函式，可以使用二分查詢來找到kbest：
如果f(i-1,k-1)<f(i,j-k)，則k<kbest，即k在圖中kbest的左邊；
如果f(i-1,k-1)>f(i,j-k)，則k>kbest，即k在圖中kbest的右邊。

程式碼

class EggDrop {
    private int[][] result;
    
    public int superEggDrop(int K,int j) {
        if (result[i][j] != -1) {
            return result[i][j];
        }
        if (i == 1) {
            return j;
        }
        if (j <= 1) {
            return j;
        }
        int lowest = log(j + 1);
        if (i >= lowest) {
            result[i][j] = lowest;
            return lowest;
        }

        int left = 1,right = j;
        while (left <= right) {
            int k = (left + right) / 2;
            int broken = dp(i - 1,k - 1);
            result[i - 1][k - 1] = broken;
            int notBroken = dp(i,j - k);
            result[i][j - k] = notBroken;

            if (broken < notBroken) {
                left = k + 1;
            } else if (broken > notBroken) {
                right = k - 1;
            } else {
                return notBroken + 1;
            }
        }
        //沒找到，最小值就在left或者right中
        return Math.min(Math.max(dp(i - 1,left - 1),dp(i,j - left)),Math.max(dp(i - 1,right - 1),j - right))) + 1;
    }
    
   private static int log(int x) {
        double r = (Math.log(x) / Math.log(2));
        if ((r == Math.floor(r)) && !Double.isInfinite(r)) {
            return (int) r;
        } else {
            return (int) r + 1;
        }
    }
}
複製程式碼

時間複雜度

現在狀態轉移方程的時間複雜度降為了 O(log_2N) ，演演算法的時間複雜度降為 O(Nlog_2^2 N) 。

優化3

現在無論是狀態總數還是狀態轉移方程都很難優化了，但還有一種演演算法有更低的時間複雜度。
我們定義一個新的狀態g(i,j)，它表示用j個蛋嘗試i次在最壞情況下能確定E的最高樓層數。

動態轉移方程

假設在k層扔下一隻雞蛋：

如果碎了，則在後面的(i-1)次裡，我們要用(j-1)個蛋在下面的樓層中確定E。為了使 g(i,j)達到最大，我們當然希望下面的樓層數達到最多，這是一個子問題，答案為 g(i-1,j-1)。

如果沒碎，則在後面(i-1)次裡，我們要用j個蛋在上面的樓層中確定E，這同樣需要樓層數達到最多，便為g(i-1,j) 。

因此動態轉移方程為：

g(i,j)=g(i-1,j-1)+g(i-1,j)+1
複製程式碼

邊界值

當i=1時，表示只嘗試一次，那最多隻能確定一層樓，即g(1,j)=1 (j>=1)

當j=1是，表示只有一個蛋，那隻能第一層一層層往上扔，最壞情況下一直扔到頂層，即g(i,1)=i (i>=1)。

然後我們的目標就是找到一個嘗試次數x，使x滿足g(x-1,m)<n且g(x,m)>=n。

程式碼

public class EggDrop {

    private int dp(int iTime,int j) {
        if (iTime == 1) {
            return 1;
        }
        if (j == 1) {
            return iTime;
        }
        return dp(iTime - 1,j - 1) + dp(iTime - 1,j) + 1;
    }

    public int superEggDrop(int i,int j) {
        int ans = 1;
        while (dp(ans,i) < j) {
            ans++;
        }
        return ans;
    }
}
複製程式碼

這個演演算法的時間複雜度是 $O(\sqrt{N})$ ，證明比較複雜，這裡就不展開了，可以參考文末文獻。

小結

最後我們總結一下動態規劃演演算法的解題方法：

四步走：問題建模、定義子問題、動態轉移方程、最優子結構。
時間複雜度 = 狀態總數 * 狀態轉移方程的時間複雜度。
考慮是否需要設定標記，例如有的題目還要求打印出最小路徑。
寫程式碼，遞迴和迴圈選擇你熟悉的來寫。
如果時間複雜度不能接受，考慮能不能優化演演算法。

優化思路

是否能夠剪枝優化（優化1）
從函式本身的數學性質入手（優化2）
轉換思路，嘗試一下別的狀態轉移方程（優化3）
……

動態規劃在演演算法中屬於較難的題型，難點就在定義子問題和寫出動態轉移方程。所以需要勤加練習，訓練自己的思維。這裡給出幾道動態規劃的經典題目，這幾道題都需要吃透，可以用本文中提到的四步走的方式來思考和解題。

Maximum Length of Repeated Subarray
Coin Change
Partition Equal Subset Sum

最後：

參考文獻

國家集訓隊朱晨光論文
 知乎-如何用最少的次數測出雞蛋會在哪一層摔碎？

面試官：你有m個雞蛋，如何用最少的次數測出雞蛋會在哪一層碎？

不限雞蛋

限制雞蛋個數

四步走

建模

劃分子問題

列出狀態轉移方程和初值

是否滿足最優子結構

一個反例

時間複雜度

遞迴樹

程式碼

時間複雜度

優化

優化1

決策樹

程式碼

優化2

程式碼

時間複雜度

優化3

動態轉移方程

邊界值

程式碼

小結

優化思路

最後：

參考文獻

相關推薦