Merge branch 'master' of https://github.com/azl397985856/leetcode

robot · robot · commit 783bc5ca77e1 · 2024-11-24T23:25:19.000+08:00
diff --git a/problems/887.super-egg-drop.md b/problems/887.super-egg-drop.md
@@ -1,6 +1,6 @@
 ## 题目地址(887. 鸡蛋掉落)
 
-原题地址：https://leetcode-cn.com/problems/super-egg-drop/
+https://leetcode-cn.com/problems/super-egg-drop/
 
 ## 题目描述
 
@@ -50,23 +50,20 @@
 
 本题也是 vivo 2020 年提前批的一个笔试题。时间一个小时，一共三道题，分别是本题，合并 k 个链表，以及种花问题。
 
-这道题我在很早的时候做过，也写了[题解](https://github.com/azl397985856/leetcode/blob/master/problems/887.super-egg-drop.md "887.super-egg-drop 题解")。现在看来，思路没有讲清楚。没有讲当时的思考过程还原出来，导致大家看的不太明白。今天给大家带来的是 887.super-egg-drop 题解的**重制版**。思路更清晰，讲解更透彻，如果觉得有用，那就转发在看支持一下？OK，我们来看下这道题吧。
+这道题我在很早的时候做过，也写了题解。现在看来，思路没有讲清楚。没有讲当时的思考过程还原出来，导致大家看的不太明白。今天给大家带来的是 887.super-egg-drop 题解的**重制版**。思路更清晰，讲解更透彻，如果觉得有用，那就转发在看支持一下？OK，我们来看下这道题吧。
 
 这道题乍一看很复杂，我们不妨从几个简单的例子入手，尝试打开思路。
 
-假如有 2 个鸡蛋，6 层楼。 我们应该先从哪层楼开始扔呢？想了一会，没有什么好的办法。我们来考虑使用暴力的手段。
+为了方便描述，我将 f(i, j) 表示有 i 个鸡蛋， j 层楼，在最坏情况下，最少的次数。
 
-![](https://p.ipic.vip/120oh0.jpg)
-（图 1. 这种思路是不对的）
+假如有 2 个鸡蛋，6 层楼。 我们应该先从哪层楼开始扔呢？想了一会，没有什么好的办法。我们来考虑使用暴力的手段。
 
 既然我不知道先从哪层楼开始扔是最优的，那我就依次模拟从第 1，第 2。。。第 6 层扔。每一层楼丢鸡蛋，都有两种可能，碎或者不碎。由于是最坏的情况，因此我们需要模拟两种情况，并取两种情况中的扔次数的较大值（较大值就是最坏情况）。 然后我们从六种扔法中选择最少次数的即可。
 
 ![](https://p.ipic.vip/5vz4r2.jpg)
-（图 2. 应该是这样的）
+（图1）
 
-而每一次选择从第几层楼扔之后，剩下的问题似乎是一个规模变小的同样问题。嗯哼？递归？
-
-为了方便描述，我将 f(i, j) 表示有 i 个鸡蛋， j 层楼，在最坏情况下，最少的次数。
+而每一次选择从第几层楼扔之后，剩下的问题似乎是一个规模变小的同样问题。比如选择从 i 楼扔，如果碎了，我们需要的答案就是 1 + f(k-1, i-1)，如果没有碎，需要在找 [i+1, n]，这其实等价于在 [1,n-i]中找。我们发现可以将问题转化为规模更小的子问题，因此不难想到递归来解决。
 
 伪代码：
 
@@ -98,9 +95,9 @@ class Solution:
         return ans
 ```
 
-可是如何这就结束的话，这道题也不能是 hard，而且这道题是公认难度较大的 hard 之一。
+可是如何这就结束的话，这道题也不能是 hard，而且这道题是公认难度较大的 hard 之一，肯定不会被这么轻松解决。
 
-上面的代码会 TLE，我们尝试使用记忆化递归来试一下，看能不能 AC。
+实际上上面的代码会 TLE，我们尝试使用记忆化递归来试一下，看能不能 AC。
 
 ```py
 
@@ -121,19 +118,19 @@ class Solution:
 那只好 bottom-up（动态规划）啦。
 
 ![](https://p.ipic.vip/gnmqq1.jpg)
-(图 3)
+(图 2)
 
 我将上面的过程简写成如下形式：
 
 ![](https://p.ipic.vip/m4ruew.jpg)
-(图 4)
+(图 3)
 
 与其递归地进行这个过程，我们可以使用迭代的方式。 相比于上面的递归式，减少了栈开销。然而两者有着很多的相似之处。
 
 如果说递归是用函数调用来模拟所有情况， 那么动态规划就是用表来模拟。我们知道所有的情况，无非就是 N 和 K 的所有组合，我们怎么去枚举 K 和 N 的所有组合？ 当然是套两层循环啦！
 
 ![](https://p.ipic.vip/o91aox.jpg)
-（图 5. 递归 vs 迭代）
+（图 4. 递归 vs 迭代）
 
 如上，你将 dp[i][j] 看成 superEggDrop(i, j)，是不是和递归是一摸一样？
 
@@ -142,41 +139,41 @@ class Solution:
 ```py
 class Solution:
     def superEggDrop(self, K: int, N: int) -> int:
-        for i in range(K + 1):
-            for j in range(N + 1):
-                if i == 1:
-                    dp[i][j] = j
-                if j == 1 or j == 0:
-                    dp[i][j] == j
-                dp[i][j] = j
-                for k in range(1, j + 1):
-                    dp[i][j] = min(dp[i][j], max(dp[i - 1][k - 1] + 1, dp[i][j - k] + 1))
-        return dp[K][N]
+        dp = [[i for _ in range(K+1)] for i in range(N + 1)]
+        for i in range(N + 1):
+            for j in range(1, K + 1):
+                dp[i][j] = i
+                if j == 1:
+                    continue
+                if i == 1 or i == 0:
+                    break
+                for k in range(1, i + 1):
+                    dp[i][j] = min(dp[i][j], max(dp[k - 1][j-1] + 1, dp[i-k][j] + 1))
+        return dp[N][K]
 ```
 
 值得注意的是，在这里内外循环的顺序无关紧要，并且内外循坏的顺序对我们写代码来说复杂程度也是类似的，各位客官可以随意调整内外循环的顺序。比如这样也是可以的：
 
 ```py
 class Solution:
     def superEggDrop(self, K: int, N: int) -> int:
-        dp = [[0] * (K + 1) for _ in range(N + 1)]
-
-        for i in range(N + 1):
-            for j in range( K + 1):
-                if j == 1:
-                    dp[i][j] = i
-                if i == 1 or i == 0:
-                    dp[i][j] == i
-                dp[i][j] = i
-                for k in range(1, i + 1):
-                    dp[i][j] = min(dp[i][j], max(dp[k - 1][j - 1] + 1, dp[i - k][j] + 1))
-        return dp[N][K]
-        dp = [[0] * (N + 1) for _ in range(K + 1)]
+        dp = [[i for i in range(N+1)] for _ in range(K + 1)]
+        for i in range(1, K + 1):
+            for j in range(N + 1):
+                dp[i][j] = j
+                if i == 1:
+                    break
+                if j == 1 or j == 0:
+                    continue
+                for k in range(1, j + 1):
+                    dp[i][j] = min(dp[i][j], max(dp[i - 1][k - 1] + 1, dp[i][j - k] + 1))
+        return dp[K][N]
 ```
 
 总结一下，上面的解题方法思路是：
 
 ![](https://p.ipic.vip/ynsszu.jpg)
+(图 5)
 
 然而这样还是不能 AC。这正是这道题困难的地方。 **一道题目往往有不止一种状态转移方程，而不同的状态转移方程往往性能是不同的。**
 
@@ -185,6 +182,7 @@ class Solution:
 把思路逆转！
 
 ![](https://p.ipic.vip/jtgl7i.jpg)
+(图 6)
 
 > 这是《逆转裁判》 中经典的台词， 主角在深处绝境的时候，会突然冒出这句话，从而逆转思维，寻求突破口。
 
@@ -197,83 +195,140 @@ class Solution:
 - ...
 - ”f 函数啊 f 函数，我扔 m 次呢？“， 也就是判断 f(k, m) >= N 的返回值
 
-我们只需要返回第一个返回值为 true 的 m 即可。
+我们只需要返回第一个返回值为 true 的 m 即可。由于 m 不会大于 N，因此时间复杂度也相对可控。这么做的好处就是不用思考从哪里开始扔，扔完之后下一次从哪里扔。
+
+对于这种二段性的题目应该想到二分法，如果你没想起来，请先观看我的仓库里的二分专题哦。实际上不二分也完全可以通过此题目，具体下方代码，有实现带二分的和不带二分的。
 
-> 想到这里，我条件发射地想到了二分法。 聪明的小朋友们，你们觉得二分可以么？为什么？欢迎评论区留言讨论。
+最后剩下一个问题。这个神奇的 f 函数怎么实现呢？
 
-那么这个神奇的 f 函数怎么实现呢？其实很简单。
+- 摔碎的情况，可以检测的最大楼层数是`f(m - 1, k - 1)`。也就是说，接下来我们需要往下找，最多可以找 f(m-1, k-1) 层
+- 没有摔碎的情况，可以检测的最大楼层数是`f(m - 1, k)`。也就是说，接下来我们需要往上找，最多可以找 f(m-1, k) 层
 
-- 摔碎的情况，可以检测的最高楼层是`f(m - 1, k - 1) + 1`。因为碎了嘛，我们多检测了摔碎的这一层。
-- 没有摔碎的情况，可以检测的最高楼层是`f(m - 1, k)`。因为没有碎，也就是说我们啥都没检测出来（对能检测的最高楼层无贡献）。
+也就是当前扔的位置上面可以有  f(m-1, k) 层，下面可以有 f(m-1, k-1) 层，这样无论鸡蛋碎不碎，我都可以检测出来。因此能检测的最大楼层数就是**向上找的最大楼层数+向下找的最大楼层数+1**，其中 1 表示当前层，即 `f(m - 1, k - 1) + f(m - 1, k) + 1`
 
-我们来看下代码：
+首先我们来看下二分代码：
 
 ```py
 class Solution:
     def superEggDrop(self, K: int, N: int) -> int:
+        
+        @cache
         def f(m, k):
             if k == 0 or m == 0: return 0
             return f(m - 1, k - 1) + 1 +  f(m - 1, k)
-        m = 0
-        while f(m, K) < N:
-            m += 1
-        return m
+        l, r = 1, N
+        while l <= r:
+            mid = (l + r) // 2
+            if f(mid, K) >= N:
+                r = mid - 1
+            else:
+                l = mid + 1
+            
+        return l
 ```
 
-上面的代码可以 AC。我们来顺手优化成迭代式。
-
-```py
-class Solution:
-    def superEggDrop(self, K: int, N: int) -> int:
-        dp = [[0] * (K + 1) for _ in range(N + 1)]
-        m = 0
-        while dp[m][K] < N:
-            m += 1
-            for i in range(1, K + 1):
-                dp[m][i] = dp[m - 1][i - 1] + 1 + dp[m - 1][i]
-        return m
-```
+下面代码区我们实现不带二分的版本。
 
 ## 代码
 
-代码支持：JavaSCript，Python
+代码支持：Python, CPP, Java, JavaSCript
 
 Python:
 
 ```py
 class Solution:
     def superEggDrop(self, K: int, N: int) -> int:
-        dp = [[0] * (K + 1) for _ in range(N + 1)]
-        m = 0
-        while dp[m][K] < N:
-            m += 1
-            for i in range(1, K + 1):
-                dp[m][i] = dp[m - 1][i - 1] + 1 + dp[m - 1][i]
-        return m
+        dp = [[0] * (N + 1) for _ in range(K + 1)]
+        
+        for m in range(1, N + 1):
+            for k in range(1, K + 1):
+                dp[k][m] = dp[k - 1][m - 1] + 1 + dp[k][m - 1]
+                if dp[k][m] >= N:
+                    return m
+        
+        return N  # Fallback, should not reach here
+```
+
+CPP:
+
+```cpp
+#include <vector>
+#include <functional>
+
+class Solution {
+public:
+    int superEggDrop(int K, int N) {
+        std::vector<std::vector<int>> dp(K + 1, std::vector<int>(N + 1, 0));
+        
+        for (int m = 1; m <= N; ++m) {
+            for (int k = 1; k <= K; ++k) {
+                dp[k][m] = dp[k - 1][m - 1] + 1 + dp[k][m - 1];
+                if (dp[k][m] >= N) {
+                    return m;
+                }
+            }
+        }
+        
+        return N; // Fallback, should not reach here
+    }
+};
+
+```
+
+Java:
+
+```java
+import java.util.Arrays;
+
+class Solution {
+    public int superEggDrop(int K, int N) {
+        int[][] dp = new int[K + 1][N + 1];
+        
+        for (int m = 1; m <= N; ++m) {
+            for (int k = 1; k <= K; ++k) {
+                dp[k][m] = dp[k - 1][m - 1] + 1 + dp[k][m - 1];
+                if (dp[k][m] >= N) {
+                    return m;
+                }
+            }
+        }
+        
+        return N; // Fallback, should not reach here
+    }
+}
+
 ```
 
 JavaSCript:
 
 ```js
-var superEggDrop = function (K, N) {
-  // 不选择dp[K][M]的原因是dp[M][K]可以简化操作
-  const dp = Array(N + 1)
-    .fill(0)
-    .map((_) => Array(K + 1).fill(0));
-
-  let m = 0;
-  while (dp[m][K] < N) {
-    m++;
-    for (let k = 1; k <= K; ++k) dp[m][k] = dp[m - 1][k - 1] + 1 + dp[m - 1][k];
-  }
-  return m;
-};
+/**
+ * @param {number} k
+ * @param {number} n
+ * @return {number}
+ */
+var superEggDrop = function superEggDrop(K, N) {
+    const dp = Array.from({ length: K + 1 }, () => Array(N + 1).fill(0));
+    
+    for (let m = 1; m <= N; ++m) {
+        for (let k = 1; k <= K; ++k) {
+            dp[k][m] = dp[k - 1][m - 1] + 1 + dp[k][m - 1];
+            if (dp[k][m] >= N) {
+                return m;
+            }
+        }
+    }
+    
+    return N; // Fallback, should not reach here
+}
+
+
 ```
 
 **复杂度分析**
 
-- 时间复杂度：$O(m * K)$，其中 m 为答案。
-- 空间复杂度：$O(K * N)$
+- 时间复杂度：$O(N * K)$
+- 空间复杂度：$O(N * K)$
 
 对为什么用加法的同学有疑问的可以看我写的[《对《丢鸡蛋问题》的一点补充》](https://lucifer.ren/blog/2020/08/30/887.super-egg-drop-extension/)。
 
