LeetCode——高层扔鸡蛋

Q：你将获得 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

A：
大家可能会想到用二分法来解决，那么我们第一个鸡蛋在100/2=50层的位置扔下。假如碎了，那么第二个鸡蛋必须只能从第1层一直试到49层，在最坏情况下(答案为49层时)，小明共要尝试50次才能得到答案；假如没碎，那么可以用第一个鸡蛋接着在第75层尝试，循环往复直到试出答案。于是可知，用二分法，最坏情况为50次。
那么用三分法呢？第一个鸡蛋扔在33层，最坏情况是（答案为32层时），小明需要1+32=33次才能得到答案。如果是分成10份呢？第一个鸡蛋扔在10层，然后20层…知道100层，最坏情况(答案为99层时)，小明共需要扔10(第一个鸡蛋)+9(第二个鸡蛋)=19次
当然也不是分的越细越好，比如说先分成100/5=20份的话。第一次在5层扔，第二次在10层扔，…，一直扔到95层还没碎，那么就已经试了19次了。

我们设 f(k,n) 为测试n层楼，当有k个鸡蛋时，最坏情况下，最少需要测试的次数。
还是可以按照上面的方法来分析，对于k个鸡蛋中的第1个鸡蛋来说，小明在第 i 层扔了下去，于是相同的两种情况会出现：

碎了，小明还剩下k-1个鸡蛋，i-1 层待测试楼层，于是问题变为 f(k-1, i-1)
没碎，小明还剩下k个鸡蛋，n-i 层待测试楼层，于是问题变为 f(k, n-i)
所以同理可得：

之所以里面还有一层循环min，是因为要在当前情况里所有楼层都试一遍，从任一楼层开始里面选择最小的一种情况。

    public static int superEggDrop(int K, int N) {
        int[][] dp = new int[K + 1][N + 1];
        for (int i = 0; i <= K; i++) {
            for (int j = 0; j <= N; j++) {
                if (i == 0 || j == 0) {
                    dp[i][j] = 0;
                } else if (i == 1) {
                    dp[i][j] = j;
                } else
                    dp[i][j] = Integer.MAX_VALUE;
            }
        }
        for (int k = 2; k <= K; k++) {
            for (int n = 1; n <= N; n++) {
                for (int i = 1; i <= n; i++) {//在当前情况里所有楼层都试一遍
                    dp[k][n] = Math.min(dp[k][n], 1 + Math.max(dp[k - 1][i - 1], dp[k][n - i]));
                }
            }
        }
        return dp[K][N];
    }

然后这种方法尼玛超时了？！！！！毕竟是O(KNN)的时间复杂度……

啊……无语问苍天……java好惨，只能用二分+动态规划？？？
这个我借用一下别人的python代码：

/**
 * @param {number} K
 * @param {number} N
 * @return {number}
 */
let dp = undefined
var superEggDrop = function(K, N) {
    dp = new Array(K + 1)
    for(let i = 0 ;i <= K; i++) dp[i] = new Array(N + 1).fill(-1)
    return dpf(K, N)
};

// 剩余k个鸡蛋、n层楼需要遍历
function dpf(k, n) {
    if(dp[k][n]!== -1) return dp[k][n]
    if(n === 0) return 0
    if(k === 1) return n
    let ans = Infinity
    let left = 1
    let right = n
    /*
    注意， 这里的二分法不是二分法抛鸡蛋，每次抛鸡蛋实际还是暴力循环遍历。
    这里能用二分法，是因为dpf（k - 1, i - 1）和dpf(k, n - i)一个单调递增， 一个单调递减
    最大最小问题其实就是要找两者相交的那个点， 所以可以用二分法
    */
    while(left <= right) {
        const mid = Math.floor((left + right) / 2)
        const broken = dpf(k - 1, mid - 1)
        const not_broken = dpf(k, n - mid)
        if(broken > not_broken) {
            right = mid - 1
            ans = Math.min(ans, broken + 1)
        } else if(broken < not_broken){
            left = mid + 1
            ans = Math.min(ans, not_broken + 1)
        } else {
            ans = Math.min(ans, broken + 1)
            break
        }
    }
    dp[k][n] = ans
    return ans
}

实际上这个题还有种进阶解法。
我们反向考虑一下，设确定当前的鸡蛋个数和最多允许的扔鸡蛋次数，就知道能够确定 F 的最⾼楼层数

dp[k][m] = n
当前有 k 个鸡蛋，可以尝试扔 m 次鸡蛋
这个状态下，最坏情况下最多能确切测试⼀栋 n 层的楼
⽐如说 dp[1][7] = 7 表⽰：现在有 1 个鸡蛋，允许你扔 7 次;这个状态下最多给你 7 层楼，使得你可以确定楼层 F 使得鸡蛋恰好摔不碎（⼀层⼀层线性探查嘛）

基于下⾯两个事实：
1.⽆论你在哪层楼扔鸡蛋，鸡蛋只可能摔碎或者没摔碎，碎了的话就测楼下，没碎的话就测楼上。
2.⽆论你上楼还是下楼，总的楼层数 = 楼上的楼层数 + 楼下的楼层数 +1（当前这层楼）。
根据这个特点，可以写出下⾯的状态转移⽅程：
dp[k][m] = dp[k][m - 1] + dp[k - 1][m - 1] + 1
dp[k][m - 1] 就是楼上的楼层数，因为鸡蛋个数 k 不变，也就是鸡蛋没碎，扔鸡蛋次数 m 减⼀；
dp[k - 1][m - 1] 就是楼下的楼层数，因为鸡蛋个数 k 减⼀，也就是鸡蛋碎了，同时扔鸡蛋次数 m 减⼀。
PS：这个 m 为什么要减⼀⽽不是加⼀？之前定义得很清楚，这个 m 是⼀个允许的次数上界，⽽不是扔了⼏次。

扫描二维码关注公众号，回复： 10229407 查看本文章

    public static int superEggDrop(int K, int N) {
        if (N < 2 || K == 1)
            return N;
        int[][] dp = new int[K + 1][N + 1];
        int m = 0;
        //最坏情况下最多能测试 N 层楼
        while (dp[K][m] < N) {
            m++;
            for (int k = 1; k <= K; k++) {
                dp[k][m] = dp[k - 1][m - 1] + dp[k][m - 1] + 1;
            }
        }
        return m;
    }

LeetCode——高层扔鸡蛋

猜你喜欢