鸡蛋掉落--LeetCode887

鸡蛋掉落–LeetCode887

题目

你将获得 K 个鸡蛋，并可以使用一栋从 1 到 N 共有 N 层楼的建筑。每个蛋的功能都是一样的，如果一个蛋碎了，你就不能再把它掉下去。你知道存在楼层 F ，满足 0 <= F <= N 任何从高于 F 的楼层落下的鸡蛋都会碎，从 F 楼层或比它低的楼层落下的鸡蛋都不会破。每次移动，你可以取一个鸡蛋（如果你有完整的鸡蛋）并把它从任一楼层 X 扔下（满足 1 <= X <= N）。

你的目标是确切地知道 F 的值是多少。无论 F 的初始值如何，你确定 F 的值的最小移动次数是多少？
示例：

输入：K = 1, N = 2
输出：2
解释：
鸡蛋从 1 楼掉落。如果它碎了，我们肯定知道 F = 0 。
否则，鸡蛋从 2 楼掉落。如果它碎了，我们肯定知道 F = 1 。
如果它没碎，那么我们肯定知道 F = 2 。
因此，在最坏的情况下我们需要移动 2 次以确定 F 是多少。

思路：动态规划

动态规划初始条件：当楼层数 N 等于 0 时，显然不需要扔鸡蛋；当楼层数 N 等于 1 ，在第一层扔鸡蛋即可根据蛋碎没碎确定出F；鸡蛋数 K 为 1 时，只能从第一层向上线性扫描所有楼层且一定能够找到F的位置，最坏情况下移动次数为N。
转移方程：假设在第i层扔鸡蛋，有两种情况：

• 鸡蛋碎了，说明F < i，鸡蛋的个数 K 应该减一，搜索的楼层区间应该从 [1…N] 变为 [1…i-1] 共 i-1 层楼；
• 鸡蛋没碎，说明 F >= i，此时鸡蛋的个数 K 不变，搜索的楼层区间应该从 [1…N] 变为 [i+1…N] 共 N-i 层楼。
• 题目条件是“无论 F 的初始值如何”，也就是要找到最坏情况下的查找次数，因此要选择上面两个区间中较大的那个次数。（举例：第一个区间找到F需要5次，第二个区间找到F需要6次，那么题目要求的“无论 F 的初始值如何，你确定 F 的值的最小移动次数是多少？”就应该是6次。最小移动次数怎么理解？那我移动7次，8次…都行啊，所以6次是不管F取多少情况下最小的次数）

放两个LeetCode讨论区大佬的链接：
labuladong的题解（Python）

Shellbye Bai的题解（Java）

代码如下：

class Solution {
    public int superEggDrop(int K, int N) {
        // 初始状态，三个情况含义不一样
        if (N == 0 || N == 1 || K == 1) {
            return N;
        }
        int minTimes = N;// 最坏情况下遍历需要N次，所以初始化为N
        for (int i = 1; i <= N; i++) {
            // 根据蛋碎没碎分两种情况考虑
            int currMax = Math.max(superEggDrop(K-1, i-1), superEggDrop(K, N-i));
            minTimes = Math.min(1+currMax, minTimes);// 这里currMax加一意思是上一步不管蛋碎没碎都算移动了一次
        }
        return minTimes;
    }
}

上面的代码在LeetCode中运行超时了，主要原因是递归的过程中存在大量的重复计算。下面使用空间换时间来进行优化：

class Solution {
    public int superEggDrop(int K, int N) {
        // 初始条件
        int[][] dp = new int[K+1][N+1];
        for (int i = 1; i <= K; i++) {
            dp[i][0] = 0;// 0层楼
        }
        for (int i = 1; i <= N; i++) {
            dp[1][i] = i;// 只有一个鸡蛋
            dp[0][i] = 0;// 0个鸡蛋
        }

        for (int k = 2; k <= K; k++) {
            for (int n = 1; n <= N; n++) {
                int minTimes = N*N;
                for (int i = 1; i <= n; i++) {
                    int currMax = Math.max(dp[k-1][i-1], dp[k][n-i]);
                    minTimes = Math.min(minTimes, 1+currMax);
                }
                dp[k][n] = minTimes;
            }
        }
        return dp[K][N];
    }
}

注：在LeetCode中运行依旧超时，还需优化。。。