【leetcode_887】鸡蛋掉落

你将获得 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 <= K <= 100 1 <= N <= 10000

思路

最简单最暴力的解法，就是计算 鸡蛋在某一层碎或没碎之后，剩下的鸡蛋要在剩下的相应层里边找到F最小移动次数是多少，碎和没碎两种情况中，要选择最大的那个最小移动步数，作为鸡蛋在这一层扔下的情况下要找出F所使用的最小移动步数 最后在试过所有层之后，取最小的移动次数。

class Solution {
public:
    
    int minstep(int K, int N, int dp[101][10001]) {
        // 如果dp[K][N]有值则直接返回
        if(dp[K][N] != -1) {
            return dp[K][N];
        }
        // 如果鸡蛋只有一个，或者楼层只有一个了，就返回楼层数
        else if (N==1 || K==1 || N==0) {
            dp[K][N] = N;
        }
        // 否则遍历各种情况
        else {
            int minimun = N;
            for (int i = 1; i <= N; i++) {
                int temp_min = max(minstep(K - 1, i - 1, dp), minstep(K, N - i, dp)); // 碎了往下找，没碎往上找
                minimun = min(minimun, 1 + temp_min);
            }
            dp[K][N] = minimun;
        }
        return dp[K][N];
    }
    
    
    int superEggDrop(int K, int N) {
        int dp[100+1][10000+1];
        memset(dp, -1, sizeof(dp));
        return minstep(K, N, dp);
        
        
    }
};

感觉应该是行的，但是超出时间限制了！！！

别人的解答

无奈，不会做，只好去看别人的解答了
https://github.com/Shellbye/Shellbye.github.io/issues/42
这个讲的非常详细。

基于二分查找的动态规划还没看。

换一种思路，则是“求k个鸡蛋在m步内可以测出多少层”，那么当m=k时可测出>=N时就可以了。我们令dp[k][m]表示k个鸡蛋在m步内可以测出的最多的层数，那么当我们在第X层扔鸡蛋的时候，就有两种情况：

鸡蛋碎了，我们少了一颗鸡蛋，也用掉了一步，此时测出N - X + dp[k-1][m-1]层，X和它上面的N-X层已经通过这次扔鸡蛋确定大于F；
鸡蛋没碎，鸡蛋的数量没有变，但是用掉了一步，剩余X + dp[k][m-1]，X层及其以下已经通过这次扔鸡蛋确定不会大于F；

class Solution {
    public int superEggDrop(int K, int N) {
        int[][] dp = new int[K + 1][N + 1];
        for (int m = 1; m <= N; m++) {
            dp[0][m] = 0; // zero egg
            for (int k = 1; k <= K; k++) {
                dp[k][m] = dp[k][m - 1] + dp[k - 1][m - 1] + 1;
                if (dp[k][m] >= N) {
                    return m;
                }
            }
        }
        return N;
    }
}

（有点被绕晕。。。。）