LeetCode 887 雞蛋掉落(dp,記憶化搜索，二分)

題目鏈接：雞蛋掉落

你將獲得 K 個雞蛋，並可以使用一棟從 1 到 N 共有 N 層樓的建築。

每個蛋的功能都是一樣的，如果一個蛋碎了，你就不能再把它掉下去。

你知道存在樓層 F ，滿足 0 <= F <= N 任何從高於 F 的樓層落下的雞蛋都會碎，從 F 樓層或比它低的樓層落下的雞蛋都不會破。

每次移動，你可以取一個雞蛋（如果你有完整的雞蛋）並把它從任一樓層 X 扔下（滿足 1 <= X <= N）。

你的目標是確切地知道 F 的值是多少。

無論 F 的初始值如何，你確定 F 的值的最小移動次數是多少？

示例 1：

輸入：K = 1, N = 2
輸出：2
解釋：
雞蛋從 1 樓掉落。如果它碎了，我們肯定知道 F = 0 。
否則，雞蛋從 2 樓掉落。如果它碎了，我們肯定知道 F = 1 。
如果它沒碎，那麼我們肯定知道 F = 2 。
因此，在最壞的情況下我們需要移動 2 次以確定 F 是多少。

示例 2：

輸入：K = 2, N = 6
輸出：3

示例 3：

輸入：K = 3, N = 14
輸出：4

提示：

1. 1 <= K <= 100
2. 1 <= N <= 10000

思路

兩種方法：

方法一：記憶化搜索+二分

我們考慮一下dp[t][n]代表，現在有t層樓，n個雞蛋，所能達到的最大樓層。現在定義一個k (1<=k<=t)，我們從第k層扔下去一個雞蛋，如果雞蛋碎了，我們就要往低一點的樓層去找，則當前dp[t][n]狀態是dp[k-1][n-1]+1(k-1的原因是第k層已經扔過了)，如果雞蛋沒碎，我們要向上找，當前的狀態dp[t][n]等價於dp[t-k][n]+1。

因爲我們考慮的是最壞情況下找到雞蛋的次數，所以狀態轉移方程爲，$dp[t][n]=max(dp[k-1][n-1],dp[t-k][n])+1$

那麼問題來了，我們還有一個k沒有確定，k的取值範圍是(1<=k<=t)，我們當然可以枚舉一下所有的k，然後在所有的k中取最小值(因爲題目求的是最小移動次數)，但是每次枚舉全部的k，複雜度比較高$O(KN^2)$。

於是我們需要用二分來確定k，我們觀察上面的狀態轉移方程：

• dp[k-1][n-1],k增大的時候，樓層越高，則值越大
• dp[t-k][n]，k增大的時候，樓層越小，值越小

所以一個是單調遞增的，另一個是單調遞減的，所以我們要確定的k在他們的交匯點。也就是找到使得dp[t-k][n]<=dp[t-1][n-1]的最大的k。用了二分之後的時間複雜度降爲：$O(KNlogN)$

方法二：dp

定義dp[k][step]代表由k個雞蛋，通過移動step步所能到達的確定的最大樓層。則易得

• dp[0][step]=0 : 0 個雞蛋，不論走多少步，所能確定的最大樓層永遠只是0
• dp[k][1]=1 ：不論有多少個雞蛋，如果之走一步，那麼只能確定最大1層樓。
• dp[1][step]=step：只有一個雞蛋時，能走到的最大樓層只能1層一層試，需要step次數。

根據以上條件，可以得到狀態轉移方程：

$dp[k][step]=dp[k-1][step-1]+dp[k][step-1]+1$

表示：當前樓層有k個雞蛋，走了step步能確定的最大樓層數量是，丟了雞蛋碎了走一步能確定的最大樓層(dp[k-1][step-1])+丟了雞蛋沒碎走一步所能確定的最大樓層(dp[k][step-1])+當前這一層丟了雞蛋只能確定的層數1.時間複雜度爲：$O(K*N)$

代碼

方法一：記憶化搜索+二分

沒用二分超時版：

class Solution
{
public:
    // 返回有t層，n個雞蛋的最小移動次數,k是枚舉的中間樓層
    int dp[10000 + 50][100 + 50];
    int dfs(int t, int n)
    {
        if (~dp[t][n])
            return dp[t][n];
        if (t == 0 || n == 0)
            return 0;
        if (n == 1)
            return t;
        if (t == 1)
            return 1;
        int minn = INT_MAX;
        for (int k = 1; k <= t; k++)
        {
            minn = min(minn, max(dfs(k - 1, n - 1), dfs(t - k, n)) + 1);
        }
        return dp[t][n] = minn;
    }
    // K 代表雞蛋個數，N 代表樓層數
    int superEggDrop(int K, int N)
    {
        memset(dp, -1, sizeof(dp));
        return dfs(N, K);
    }
};

把k二分後，AC版：

class Solution
{
public:
    // 返回有t層，n個雞蛋的最小移動次數,k是枚舉的中間樓層
    int dp[10000 + 50][100 + 50];
    int dfs(int t, int n)
    {
        if (~dp[t][n])
            return dp[t][n];
        if (t == 0 || n == 0)
            return 0;
        if (n == 1)
            return t;
        if (t == 1)
            return 1;
        int l = 1, r = t;
        while (r - l > 1)
        {
            int mid = (l + r) >> 1;
            int ans1 = dfs(mid - 1, n - 1);
            int ans2 = dfs(t - mid, n);
            if (ans1 < ans2)
                l = mid;
            else if (ans1 > ans2)
                r = mid;
            else
                l = r = mid;
        }
        return dp[t][n] = 1 + min(max(dfs(l - 1, n - 1), dfs(t - l, n)),
                                  max(dfs(r - 1, n - 1), dfs(t - r, n)));
    }
    // K 代表雞蛋個數，N 代表樓層數
    int superEggDrop(int K, int N)
    {
        memset(dp, -1, sizeof(dp));
        return dfs(N, K);
    }
};

方法二：dp

class Solution
{
public:
    // K個雞蛋，N層樓
    int superEggDrop(int K, int N)
    {
        // dp[k][step]表示給k個雞蛋，移動step步所能達到的最大層數
        vector<vector<int>> dp(K + 1, vector<int>(N + 1, 0));
        for (int step = 1; step < N; step++)
        {
            dp[0][step] = 0;
            for (int k = 1; k <= K; k++)
            {
                dp[k][step] = dp[k][step - 1] + dp[k - 1][step - 1] + 1;
                if (dp[k][step] >= N)
                    return step;
            }
        }
        return N;
    }
};