leetcode 887. 鸡蛋掉落

@(labuladong的算法小抄)[dp]

leetcode 887. 鸡蛋掉落

题目描述

解题思路

本题的问题为：最坏情况下，至少要扔几次鸡蛋，才能确定楼层F

思路一：超时的dp

参考：labuladong的算法小抄P168

class Solution {
    public int superEggDrop(int K, int N) {
        /* 定义：鸡蛋数为k，可选楼层数为n时，最少扔鸡蛋次数为dp[k][n] */
        int[][] dp = new int[K + 1][N + 1];
        /* 由于是求最少次数，所以dp数组初始化为最大值 */
        for (int i = 0; i <= K; i++) Arrays.fill(dp[i], Integer.MAX_VALUE);
        /* base case */
        /* dp[1][n] = n */
        for (int i = 0; i <= N; i++) dp[1][i] = i;
        /* dp[k][0] = 0 */
        for (int i = 0; i <= K; i++) {
            dp[i][0] = 0;
        }

        for (int k = 2; k <= K; k++) {
            for (int n = 1; n <= N; n++) {
	            /* 尝试在所有楼层1≤i≤N扔鸡蛋，每次选择尝试次数最少的那一层 */
                for (int i = 1; i <= n; i++) {
                    /* 选择一：碎了，就需要去低层扔，鸡蛋数-1，层数变为i-1 */
                    /* 选择二：没碎，就需要去高层扔，鸡蛋数不变，层数变为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];
    }
}

思路二：二分搜索法

参考：labuladong的算法小抄P17

上图的函数是随着选择扔鸡蛋的楼层号i增大，取去高层和去低层中最大的次数 max(dp[k - 1][i - 1], dp[k][n - i])的函数，左侧单调递减，右侧单调递增。

由于满足单调性，现在的目标就是要用二分搜索找到
这个函数的最低点。

如果在mid处扔鸡蛋，没碎的扔鸡蛋次数dp[k][n-i]更大，说明mid此时在函数最低点的左边（对应图中mid1），因此要去右边继续搜索；

如果在mid处扔鸡蛋，碎了的扔鸡蛋次数dp[k-1][i-1]更大，说明mid此时在函数最低点的右边（对应图中mid2），因此要去左边继续搜索；

class Solution {
    public int superEggDrop(int K, int N) {
        /* 定义：鸡蛋数为k，可选楼层数为n时，最坏情况下的最少扔鸡蛋次数为dp[k][n] */
        int[][] dp = new int[K + 1][N + 1];
        /* 由于是求最少次数，所以dp数组初始化为最大值 */
        for (int i = 0; i <= K; i++) Arrays.fill(dp[i], Integer.MAX_VALUE);
        /* base case */
        /* dp[1][n] = n */
        for (int i = 0; i <= N; i++) dp[1][i] = i;
        /* dp[k][0] = 0 */
        for (int i = 0; i <= K; i++) {
            dp[i][0] = 0;
        }

        for (int k = 2; k <= K; k++) {
            for (int n = 1; n <= N; n++) {
                /* 二分搜索所有的楼层选择 */
                int low = 1, high = n;
                while (low <= high) {
                    int mid = low + (high - low) / 2;
                    /* 碎了，就需要去低层扔，broken为此时的最少扔鸡蛋次数 */
                    int broken = dp[k - 1][mid - 1];
                    /* 没碎，就需要去高层扔，not_broken为此时的最少扔鸡蛋次数 */
                    int not_broken = dp[k][n - mid];
                    /* dp[k][n] = min(1 + max(碎了，没碎)) */
                    if (broken > not_broken) {
                        high = mid - 1;
                        dp[k][n] = Math.min(dp[k][n], broken + 1);
                    } else {
                        low = mid + 1;
                        dp[k][n] = Math.min(dp[k][n], not_broken + 1);
                    }
                }
            }
        }
        return dp[K][N];
    }
}