LC 鸡蛋掉落

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

作者：力扣 (LeetCode)
链接：https://leetcode-cn.com/leetbook/read/top-interview-questions/xmup75/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

方法一：动态规划 + 二分搜索
思路和算法

我们可以考虑使用动态规划来做这道题，状态可以表示成 (K, N)，其中 K 为鸡蛋数，N为楼层数。当我们从第 X楼扔鸡蛋的时候：

如果鸡蛋不碎，那么状态变成 (K, N-X)，即我们鸡蛋的数目不变，但答案只可能在上方的 N-X 层楼了。也就是说，我们把原问题缩小成了一个规模为 (K, N-X) 的子问题；

如果鸡蛋碎了，那么状态变成 (K-1, X-1)，即我们少了一个鸡蛋，但我们知道答案只可能在第 X楼下方的 X-1 层楼中了。也就是说，我们把原问题缩小成了一个规模为 (K-1, X-1) 的子问题。

这样一来，我们定义 dp(K, N)为在状态 (K, N)下最少需要的步数。根据以上分析我们可以列出状态转移方程：

这个状态转移方程是如何得来的呢？对于 dp(K, N)而言，我们像上面分析的那样，枚举第一个鸡蛋扔在的楼层数 X。由于我们并不知道真正的 F 值，因此我们必须保证 鸡蛋碎了之后接下来需要的步数 和 鸡蛋没碎之后接下来需要的步数 二者的 最大值 最小，这样就保证了在 最坏情况下（也就是无论 FF 的值如何） dp(K, N)的值最小。如果能理解这一点，也就能理解上面的状态转移方程，即最小化

如果我们直接暴力转移求解每个状态的 dp值，时间复杂度是为 O(KN^2)，即一共有 O(KN)个状态，对于每个状态枚举扔鸡蛋的楼层 X，需要 O(N)的时间。这无疑在当前数据范围下是会超出时间限制的，因此我们需要想办法优化枚举的时间复杂度。

我们观察到 dp(K, N)是一个关于 N的单调递增函数，也就是说在鸡蛋数 K固定的情况下，楼层数N 越多，需要的步数一定不会变少。在上述的状态转移方程中，第一项 是一个随 XX 的增加而单调递增的函数，第二项是一个随着 XX 的增加而单调递减的函数。

这如何帮助我们来优化这个问题呢？当 X 增加时，单调递增而 单调递减，我们可以想象在一个直角坐标系中，横坐标为 X，纵坐标为和。当一个函数单调递增而另一个函数单调递减时，我们如何找到一个位置使得它们的最大值最小呢？

如上图所示，如果这两个函数都是连续函数，那么我们只需要找出这两个函数的交点，在交点处就能保证这两个函数的最大值最小。但在本题中，和 都是离散函数，也就是说，X 的值只能取 1, 2, 3 等等。在这种情况下，我们需要找到最大的满足 <。的 X_0，以及最小的满足≥。的 X_1 ，对应到上图中，就是离这两个函数（想象中的）交点左右两侧最近的整数。

我们只需要比较在 X_0 和 X_1 处两个函数的最大值，取一个最小的作为 XX 即可。在数学上，我们可以证明出 X_0  和 X_1 相差 11，这也是比较显然的，因为它们正好夹住了那个想象中的交点，并且相距尽可能地近。因此我们就可以使用二分查找的方法找出 X_0 ，再得到 X_1 ：

我们在所有满足条件的 X上进行二分查找。对于状态 (K, N)而言，XX 即为 [1, N]中的任一整数；

在二分查找的过程中，假设当前这一步我们查找到了 X mid，如果 ，那么真正的 X_0  一定在 X mid 的左侧，否则真正的 X_0在 X mid的右侧。

二分查找的写法因人而异，本质上我们就是需要找到最大的满足 的 X_0 ，根据 Xmid进行二分边界的调整。在得到了 X_0 后，我们可以知道 X_1即为 X_0 + 1，此时我们只需要比较，取较小的那个对应的位置作为 X 即可。

这样一来，对于给定的状态 (K,N)，我们只需要 O(log N)的时间，通过二分查找就能得到最优的那个 X，因此时间复杂度从 O(KN^2) 降低至 O(KNlogN)，可以通过本题。

class Solution:
    def superEggDrop(self, K: int, N: int) -> int:
        memo = {}
        def dp(k, n):
            if (k, n) not in memo:
                if n == 0:
                    ans = 0
                elif k == 1:
                    ans = n
                else:
                    lo, hi = 1, n
                    # keep a gap of 2 X values to manually check later
                    while lo + 1 < hi:
                        x = (lo + hi) // 2
                        t1 = dp(k-1, x-1)
                        t2 = dp(k, n-x)

                        if t1 < t2:
                            lo = x
                        elif t1 > t2:
                            hi = x
                        else:
                            lo = hi = x

                    ans = 1 + min(max(dp(k-1, x-1), dp(k, n-x))
                                  for x in (lo, hi))

                memo[k, n] = ans
            return memo[k, n]

        return dp(K, N)

复杂度分析

时间复杂度：O(K∗NlogN)。我们需要计算 O(K∗N) 个状态，每个状态计算时需要 O(logN) 的时间进行二分搜索。

空间复杂度：O(K∗N)。我们需要 O(K∗N) 的空间存储每个状态的解。

class Solution:
    def superEggDrop(self, K: int, N: int) -> int:
        # Right now, dp[i] represents dp(1, i)
        dp = list(range(N+1))
        dp2 = [0] * (N+1)
        for k in range(2, K+1):
            # Now, we will develop dp2[i] = dp(k, i)
            x = 1
            for n in range(1, N+1):
                # Let's find dp2[n] = dp(k, n)
                # Increase our optimal x while we can make our answer better.
                # Notice max(dp[x-1], dp2[n-x]) > max(dp[x], dp2[n-x-1])
                # is simply max(T1(x-1), T2(x-1)) > max(T1(x), T2(x)).
                while x < n and max(dp[x-1], dp2[n-x]) >= max(dp[x], dp2[n-x-1]):
                    x += 1

                # The final answer happens at this x.
                dp2[n] = 1 + max(dp[x-1], dp2[n-x])

            dp = dp2[:]

        return dp[-1]

复杂度分析

时间复杂度：O(K * N)。我们需要计算 O(K * N)个状态，同时对于每个 K，最优解指针只会从 0 到 N 走一次，复杂度也是 O(K * N)。因此总体复杂度为 O(K * N)。

空间复杂度：O(N)。因为 dp 每一层的解只依赖于上一层的解，因此我们每次只保留一层的解，需要的空间复杂度为 O(N)。

class Solution:
    def superEggDrop(self, K: int, N: int) -> int:
        if N == 1:
            return 1
        f = [[0] * (K + 1) for _ in range(N + 1)]
        for i in range(1, K + 1):
            f[1][i] = 1
        ans = -1
        for i in range(2, N + 1):
            for j in range(1, K + 1):
                f[i][j] = 1 + f[i - 1][j - 1] + f[i - 1][j]
            if f[i][K] >= N:
                ans = i
                break
        return ans

复杂度分析

时间复杂度：O(K*N)O(K∗N)。事实上，更准确的时间复杂度应当为 O(K * T)，我们不加证明地给出 N = O(T^K)，因此有

空间复杂度：O(K*N)。