下面是这个著名谜题的实例描述，涉及 n=2 个鸡蛋和一个 k=36 层的建筑物。
假设我们想知道在一座 36 层的建筑物中，从哪些楼层可以安全地放下鸡蛋，哪些会导致鸡蛋落地时破裂。我们做几个假设：
…..跌倒后幸存的鸡蛋可以再次使用。
….. 一个破碎的鸡蛋必须被丢弃。
…..跌倒对所有鸡蛋的影响都是一样的。
…..如果鸡蛋在掉落时破碎，那么如果从更高的楼层掉落它也会破碎。
…..如果一个鸡蛋在跌落中幸存下来，那么它会在更短的跌落中幸存下来。
…..不排除一楼窗户破蛋，也不排除36楼不破蛋。
如果只有一个鸡蛋，而我们希望确保获得正确的结果，则只能以一种方式进行实验。从一楼的窗户掉下鸡蛋；如果它幸存下来，就把它从二楼的窗户扔掉。继续向上直到它破裂。在最坏的情况下，这种方法可能需要 36 次粪便。假设有 2 个鸡蛋可用。保证在所有情况下都有效的最少数量的蛋液是多少?
问题实际上并不在于找到临界楼层，而只是决定应该从哪个楼层掉落鸡蛋，从而使试验总数最小化。
资料来源：动态规划维基
方法一：递归。
在这篇文章中，我们将讨论“n”个鸡蛋和“k”个楼层的一般问题的解决方案。解决方案是尝试从每一层(从 1 到 k)扔一个鸡蛋，并递归计算最坏情况下所需的最小扔蛋次数。在最坏情况下给出最小值的下限将成为解决方案的一部分。
在以下解决方案中，我们返回最坏情况下的最小试验次数；这些解决方案也可以轻松修改以打印每次试验的楼层编号。
最坏情况的含义：最坏情况为用户提供了门槛底线的保证。例如 – 如果我们有 ‘1’ 个鸡蛋和 ‘k’ 层，我们将从一楼开始放下鸡蛋，直到鸡蛋在 ‘kth’ 层破裂，所以尝试给我们保证的次数是 ‘k’ .
1) 最优子结构：
当我们从地板 x 上掉下一个鸡蛋时，可能有两种情况(1)鸡蛋破了(2)鸡蛋没有破。
- 如果鸡蛋从’xth’ 层掉落后破裂，那么我们只需要检查低于’x’ 的楼层和剩余的鸡蛋，因为某些楼层应该存在低于’x’ 的鸡蛋不会破裂；所以问题减少到 x-1 层和 n-1 个鸡蛋。
- 如果鸡蛋从“xth”层掉下来后没有破碎，那么我们只需要检查高于“x”层的楼层；所以问题减少到’kx’层和n个鸡蛋。
由于我们需要在最坏的情况下最小化试验次数，因此我们取两种情况的最大值。我们考虑每个楼层的上述两种情况的最大值，并选择产生最少试验次数的楼层。
k ==> Number of floors
n ==> Number of Eggs
eggDrop(n, k) ==> Minimum number of trials needed to find the critical
floor in worst case.
eggDrop(n, k) = 1 + min{max(eggDrop(n – 1, x – 1), eggDrop(n, k – x)), where x is in {1, 2, …, k}}
Concept of worst case:
For example :
Let there be ‘2’ eggs and ‘2’ floors then-:
If we try throwing from ‘1st’ floor:
Number of tries in worst case= 1+max(0, 1)
0=>If the egg breaks from first floor then it is threshold floor (best case possibility).
1=>If the egg does not break from first floor we will now have ‘2’ eggs and 1 floor to test which will give answer as
‘1’.(worst case possibility)
We take the worst case possibility in account, so 1+max(0, 1)=2
If we try throwing from ‘2nd’ floor:
Number of tries in worst case= 1+max(1, 0)
1=>If the egg breaks from second floor then we will have 1 egg and 1 floor to find threshold floor.(Worst Case)
0=>If egg does not break from second floor then it is threshold floor.(Best Case)
We take worst case possibility for surety, so 1+max(1, 0)=2.
The final answer is min(1st, 2nd, 3rd….., kth floor)
So answer here is ‘2’.
下面是上述方法的实现：
C++
#include
using namespace std;
// A utility function to get
// maximum of two integers
int max(int a, int b)
{
return (a > b) ? a : b;
}
// Function to get minimum
// number of trials needed in worst
// case with n eggs and k floors
int eggDrop(int n, int k)
{
// If there are no floors,
// then no trials needed.
// OR if there is one floor,
// one trial needed.
if (k == 1 || k == 0)
return k;
// We need k trials for one
// egg and k floors
if (n == 1)
return k;
int min = INT_MAX, x, res;
// Consider all droppings from
// 1st floor to kth floor and
// return the minimum of these
// values plus 1.
for (x = 1; x <= k; x++) {
res = max(
eggDrop(n - 1, x - 1),
eggDrop(n, k - x));
if (res < min)
min = res;
}
return min + 1;
}
// Driver program to test
// to pront printDups
int main()
{
int n = 2, k = 10;
cout << "Minimum number of trials "
"in worst case with "
<< n << " eggs and " << k
<< " floors is "
<< eggDrop(n, k) << endl;
return 0;
}
// This code is contributed
// by Akanksha Rai C
#include
#include
// A utility function to get
// maximum of two integers
int max(int a, int b)
{
return (a > b) ? a : b;
}
/* Function to get minimum number of
trials needed in worst case with n eggs
and k floors */
int eggDrop(int n, int k)
{
// If there are no floors, then no
// trials needed. OR if there is
// one floor, one trial needed.
if (k == 1 || k == 0)
return k;
// We need k trials for one egg and
// k floors
if (n == 1)
return k;
int min = INT_MAX, x, res;
// Consider all droppings from 1st
// floor to kth floor and
// return the minimum of these values
// plus 1.
for (x = 1; x <= k; x++) {
res = max(
eggDrop(n - 1, x - 1),
eggDrop(n, k - x));
if (res < min)
min = res;
}
return min + 1;
}
/* Driver program to test to pront printDups*/
int main()
{
int n = 2, k = 10;
printf("nMinimum number of trials in "
"worst case with %d eggs and "
"%d floors is %d \n",
n, k, eggDrop(n, k));
return 0;
} Java
public class GFG {
/* Function to get minimum number of
trials needed in worst case with n
eggs and k floors */
static int eggDrop(int n, int k)
{
// If there are no floors, then
// no trials needed. OR if there
// is one floor, one trial needed.
if (k == 1 || k == 0)
return k;
// We need k trials for one egg
// and k floors
if (n == 1)
return k;
int min = Integer.MAX_VALUE;
int x, res;
// Consider all droppings from
// 1st floor to kth floor and
// return the minimum of these
// values plus 1.
for (x = 1; x <= k; x++) {
res = Math.max(eggDrop(n - 1, x - 1),
eggDrop(n, k - x));
if (res < min)
min = res;
}
return min + 1;
}
// Driver code
public static void main(String args[])
{
int n = 2, k = 10;
System.out.print("Minimum number of "
+ "trials in worst case with "
+ n + " eggs and " + k
+ " floors is " + eggDrop(n, k));
}
// This code is contributed by Ryuga.
}Python 3
import sys
# Function to get minimum number of trials
# needed in worst case with n eggs and k floors
def eggDrop(n, k):
# If there are no floors, then no trials
# needed. OR if there is one floor, one
# trial needed.
if (k == 1 or k == 0):
return k
# We need k trials for one egg
# and k floors
if (n == 1):
return k
min = sys.maxsize
# Consider all droppings from 1st
# floor to kth floor and return
# the minimum of these values plus 1.
for x in range(1, k + 1):
res = max(eggDrop(n - 1, x - 1),
eggDrop(n, k - x))
if (res < min):
min = res
return min + 1
# Driver Code
if __name__ == "__main__":
n = 2
k = 10
print("Minimum number of trials in worst case with",
n, "eggs and", k, "floors is", eggDrop(n, k))
# This code is contributed by ita_cC#
using System;
class GFG {
/* Function to get minimum number of
trials needed in worst case with n
eggs and k floors */
static int eggDrop(int n, int k)
{
// If there are no floors, then
// no trials needed. OR if there
// is one floor, one trial needed.
if (k == 1 || k == 0)
return k;
// We need k trials for one egg
// and k floors
if (n == 1)
return k;
int min = int.MaxValue;
int x, res;
// Consider all droppings from
// 1st floor to kth floor and
// return the minimum of these
// values plus 1.
for (x = 1; x <= k; x++) {
res = Math.Max(eggDrop(n - 1, x - 1),
eggDrop(n, k - x));
if (res < min)
min = res;
}
return min + 1;
}
// Driver code
static void Main()
{
int n = 2, k = 10;
Console.Write("Minimum number of "
+ "trials in worst case with "
+ n + " eggs and " + k
+ " floors is " + eggDrop(n, k));
}
}
// This code is contributed by Sam007.Javascript
C++
// A Dynamic Programming based for
// the Egg Dropping Puzzle
#include
#include
// A utility function to get
// maximum of two integers
int max(int a, int b)
{
return (a > b) ? a : b;
}
/* Function to get minimum
number of trials needed in worst
case with n eggs and k floors */
int eggDrop(int n, int k)
{
/* A 2D table where entry
eggFloor[i][j] will represent
minimum number of trials needed for
i eggs and j floors. */
int eggFloor[n + 1][k + 1];
int res;
int i, j, x;
// We need one trial for one floor and 0
// trials for 0 floors
for (i = 1; i <= n; i++) {
eggFloor[i][1] = 1;
eggFloor[i][0] = 0;
}
// We always need j trials for one egg
// and j floors.
for (j = 1; j <= k; j++)
eggFloor[1][j] = j;
// Fill rest of the entries in table using
// optimal substructure property
for (i = 2; i <= n; i++) {
for (j = 2; j <= k; j++) {
eggFloor[i][j] = INT_MAX;
for (x = 1; x <= j; x++) {
res = 1 + max(
eggFloor[i - 1][x - 1],
eggFloor[i][j - x]);
if (res < eggFloor[i][j])
eggFloor[i][j] = res;
}
}
}
// eggFloor[n][k] holds the result
return eggFloor[n][k];
}
/* Driver program to test to pront printDups*/
int main()
{
int n = 2, k = 36;
printf("\nMinimum number of trials "
"in worst case with %d eggs and "
"%d floors is %d \n",
n, k, eggDrop(n, k));
return 0;
} Java
// A Dynamic Programming based Java
// Program for the Egg Dropping Puzzle
class EggDrop {
// A utility function to get
// maximum of two integers
static int max(int a, int b)
{
return (a > b) ? a : b;
}
/* Function to get minimum number
of trials needed in worst
case with n eggs and k floors */
static int eggDrop(int n, int k)
{
/* A 2D table where entry eggFloor[i][j]
will represent minimum number of trials
needed for i eggs and j floors. */
int eggFloor[][] = new int[n + 1][k + 1];
int res;
int i, j, x;
// We need one trial for one floor and
// 0 trials for 0 floors
for (i = 1; i <= n; i++) {
eggFloor[i][1] = 1;
eggFloor[i][0] = 0;
}
// We always need j trials for one egg
// and j floors.
for (j = 1; j <= k; j++)
eggFloor[1][j] = j;
// Fill rest of the entries in table using
// optimal substructure property
for (i = 2; i <= n; i++) {
for (j = 2; j <= k; j++) {
eggFloor[i][j] = Integer.MAX_VALUE;
for (x = 1; x <= j; x++) {
res = 1 + max(
eggFloor[i - 1][x - 1],
eggFloor[i][j - x]);
if (res < eggFloor[i][j])
eggFloor[i][j] = res;
}
}
}
// eggFloor[n][k] holds the result
return eggFloor[n][k];
}
/* Driver program to test to pront printDups*/
public static void main(String args[])
{
int n = 2, k = 10;
System.out.println("Minimum number of trials in worst"
+ " case with "
+ n + " eggs and "
+ k + " floors is " + eggDrop(n, k));
}
}
/*This code is contributed by Rajat Mishra*/Python
# A Dynamic Programming based Python Program for the Egg Dropping Puzzle
INT_MAX = 32767
# Function to get minimum number of trials needed in worst
# case with n eggs and k floors
def eggDrop(n, k):
# A 2D table where entry eggFloor[i][j] will represent minimum
# number of trials needed for i eggs and j floors.
eggFloor = [[0 for x in range(k + 1)] for x in range(n + 1)]
# We need one trial for one floor and0 trials for 0 floors
for i in range(1, n + 1):
eggFloor[i][1] = 1
eggFloor[i][0] = 0
# We always need j trials for one egg and j floors.
for j in range(1, k + 1):
eggFloor[1][j] = j
# Fill rest of the entries in table using optimal substructure
# property
for i in range(2, n + 1):
for j in range(2, k + 1):
eggFloor[i][j] = INT_MAX
for x in range(1, j + 1):
res = 1 + max(eggFloor[i-1][x-1], eggFloor[i][j-x])
if res < eggFloor[i][j]:
eggFloor[i][j] = res
# eggFloor[n][k] holds the result
return eggFloor[n][k]
# Driver program to test to pront printDups
n = 2
k = 36
print("Minimum number of trials in worst case with" + str(n) + "eggs and "
+ str(k) + " floors is " + str(eggDrop(n, k)))
# This code is contributed by Bhavya JainC#
// A Dynamic Programming based C# Program
// for the Egg Dropping Puzzle
using System;
class GFG {
// A utility function to get maximum of
// two integers
static int max(int a, int b)
{
return (a > b) ? a : b;
}
/* Function to get minimum number of
trials needed in worst case with n
eggs and k floors */
static int eggDrop(int n, int k)
{
/* A 2D table where entry eggFloor[i][j]
will represent minimum number of trials
needed for i eggs and j floors. */
int[, ] eggFloor = new int[n + 1, k + 1];
int res;
int i, j, x;
// We need one trial for one floor and0
// trials for 0 floors
for (i = 1; i <= n; i++) {
eggFloor[i, 1] = 1;
eggFloor[i, 0] = 0;
}
// We always need j trials for one egg
// and j floors.
for (j = 1; j <= k; j++)
eggFloor[1, j] = j;
// Fill rest of the entries in table
// using optimal substructure property
for (i = 2; i <= n; i++) {
for (j = 2; j <= k; j++) {
eggFloor[i, j] = int.MaxValue;
for (x = 1; x <= j; x++) {
res = 1 + max(eggFloor[i - 1, x - 1],
eggFloor[i, j - x]);
if (res < eggFloor[i, j])
eggFloor[i, j] = res;
}
}
}
// eggFloor[n][k] holds the result
return eggFloor[n, k];
}
// Driver function
public static void Main()
{
int n = 2, k = 36;
Console.WriteLine("Minimum number of trials "
+ "in worst case with " + n + " eggs and "
+ k + "floors is " + eggDrop(n, k));
}
}
// This code is contributed by Sam007.PHP
Javascript
C++
#include
using namespace std;
#define MAX 1000
vector> memo(MAX, vector (MAX, -1));
int solveEggDrop(int n, int k) {
if(memo[n][k] != -1) { return memo[n][k];}
if (k == 1 || k == 0)
return k;
if (n == 1)
return k;
int min = INT_MAX, x, res;
for (x = 1; x <= k; x++) {
res = max(
solveEggDrop(n - 1, x - 1),
solveEggDrop(n, k - x));
if (res < min)
min = res;
}
memo[n][k] = min+1;
return min + 1;
}
int main() {
int n = 2, k = 36;
cout< 输出
Minimum number of trials in worst case with 2 eggs and 10 floors is 4输出：
Minimum number of trials in worst
case with 2 eggs and 10 floors is 4需要注意的是，上述函数一次又一次地计算相同的子问题。请参阅以下部分递归树，E(2, 2) 被评估两次。即使对于 n 和 k 的小值，在绘制完整的递归树时也会有许多重复的子问题。
E(2, 4)
|
-------------------------------------
| | | |
| | | |
x=1/ x=2/ x=3/ x=4/
/ / .... ....
/ /
E(1, 0) E(2, 3) E(1, 1) E(2, 2)
/ /... /
x=1/ .....
/
E(1, 0) E(2, 2)
/
......
Partial recursion tree for 2 eggs and 4 floors.复杂度分析：
- 时间复杂度：由于存在重叠子问题的情况，时间复杂度是指数级的。
- 辅助空间： O(1)。因为没有使用任何数据结构来存储值。
由于再次调用相同的子问题，因此该问题具有重叠子问题的属性。所以 Egg Dropping Puzzle 具有动态规划问题的两个属性(见这个和这个)。与其他典型的动态规划 (DP) 问题一样，通过以自下而上的方式构造一个临时数组 eggFloor[][] 可以避免相同子问题的重新计算。
方法二：动态规划。
在这种方法中，我们采用与上述相同的想法，而忽略了一次又一次计算子问题答案的情况。 .方法是制作一个表来存储子问题的结果，以便解决子问题，只需要从表中查找，这将花费常数时间，而早先需要指数时间。
正式用于填充 DP[i][j] 状态，其中 ‘i’ 是鸡蛋的数量，’j’ 是楼层数：
- 我们必须遍历从 ‘1’ 到 ‘j’ 的每一层 ‘x’ 并找到最小值：
(1 + max( DP[i-1][j-1], DP[i][j-x] )).这个模拟将使事情变得清楚：
i => Number of eggs
j => Number of floors
Look up find maximum
Lets fill the table for the following case:
Floors = ‘4’
Eggs = ‘2’
1 2 3 4
1 2 3 4 => 1
1 2 2 3 => 2
For ‘egg-1’ each case is the base case so the
number of attempts is equal to floor number.
For ‘egg-2’ it will take ‘1’ attempt for 1st
floor which is base case.
For floor-2 =>
Taking 1st floor 1 + max(0, DP[1][1])
Taking 2nd floor 1 + max(DP[1][1], 0)
DP[2][2] = min(1 + max(0, DP[1][1]), 1 + max(DP[1][1], 0))
For floor-3 =>
Taking 1st floor 1 + max(0, DP[2][2])
Taking 2nd floor 1 + max(DP[1][1], DP[2][1])
Taking 3rd floor 1 + max(0, DP[2][2])
DP[2][3]= min(‘all three floors’) = 2
For floor-4 =>
Taking 1st floor 1 + max(0, DP[2][3])
Taking 2nd floor 1 + max(DP[1][1], DP[2][2])
Taking 3rd floor 1 + max(DP[1][2], DP[2][1])
Taking 4th floor 1 + max(0, DP[2][3])
DP[2][4]= min(‘all four floors’) = 3
C++
// A Dynamic Programming based for
// the Egg Dropping Puzzle
#include
#include
// A utility function to get
// maximum of two integers
int max(int a, int b)
{
return (a > b) ? a : b;
}
/* Function to get minimum
number of trials needed in worst
case with n eggs and k floors */
int eggDrop(int n, int k)
{
/* A 2D table where entry
eggFloor[i][j] will represent
minimum number of trials needed for
i eggs and j floors. */
int eggFloor[n + 1][k + 1];
int res;
int i, j, x;
// We need one trial for one floor and 0
// trials for 0 floors
for (i = 1; i <= n; i++) {
eggFloor[i][1] = 1;
eggFloor[i][0] = 0;
}
// We always need j trials for one egg
// and j floors.
for (j = 1; j <= k; j++)
eggFloor[1][j] = j;
// Fill rest of the entries in table using
// optimal substructure property
for (i = 2; i <= n; i++) {
for (j = 2; j <= k; j++) {
eggFloor[i][j] = INT_MAX;
for (x = 1; x <= j; x++) {
res = 1 + max(
eggFloor[i - 1][x - 1],
eggFloor[i][j - x]);
if (res < eggFloor[i][j])
eggFloor[i][j] = res;
}
}
}
// eggFloor[n][k] holds the result
return eggFloor[n][k];
}
/* Driver program to test to pront printDups*/
int main()
{
int n = 2, k = 36;
printf("\nMinimum number of trials "
"in worst case with %d eggs and "
"%d floors is %d \n",
n, k, eggDrop(n, k));
return 0;
}
Java
// A Dynamic Programming based Java
// Program for the Egg Dropping Puzzle
class EggDrop {
// A utility function to get
// maximum of two integers
static int max(int a, int b)
{
return (a > b) ? a : b;
}
/* Function to get minimum number
of trials needed in worst
case with n eggs and k floors */
static int eggDrop(int n, int k)
{
/* A 2D table where entry eggFloor[i][j]
will represent minimum number of trials
needed for i eggs and j floors. */
int eggFloor[][] = new int[n + 1][k + 1];
int res;
int i, j, x;
// We need one trial for one floor and
// 0 trials for 0 floors
for (i = 1; i <= n; i++) {
eggFloor[i][1] = 1;
eggFloor[i][0] = 0;
}
// We always need j trials for one egg
// and j floors.
for (j = 1; j <= k; j++)
eggFloor[1][j] = j;
// Fill rest of the entries in table using
// optimal substructure property
for (i = 2; i <= n; i++) {
for (j = 2; j <= k; j++) {
eggFloor[i][j] = Integer.MAX_VALUE;
for (x = 1; x <= j; x++) {
res = 1 + max(
eggFloor[i - 1][x - 1],
eggFloor[i][j - x]);
if (res < eggFloor[i][j])
eggFloor[i][j] = res;
}
}
}
// eggFloor[n][k] holds the result
return eggFloor[n][k];
}
/* Driver program to test to pront printDups*/
public static void main(String args[])
{
int n = 2, k = 10;
System.out.println("Minimum number of trials in worst"
+ " case with "
+ n + " eggs and "
+ k + " floors is " + eggDrop(n, k));
}
}
/*This code is contributed by Rajat Mishra*/
Python
# A Dynamic Programming based Python Program for the Egg Dropping Puzzle
INT_MAX = 32767
# Function to get minimum number of trials needed in worst
# case with n eggs and k floors
def eggDrop(n, k):
# A 2D table where entry eggFloor[i][j] will represent minimum
# number of trials needed for i eggs and j floors.
eggFloor = [[0 for x in range(k + 1)] for x in range(n + 1)]
# We need one trial for one floor and0 trials for 0 floors
for i in range(1, n + 1):
eggFloor[i][1] = 1
eggFloor[i][0] = 0
# We always need j trials for one egg and j floors.
for j in range(1, k + 1):
eggFloor[1][j] = j
# Fill rest of the entries in table using optimal substructure
# property
for i in range(2, n + 1):
for j in range(2, k + 1):
eggFloor[i][j] = INT_MAX
for x in range(1, j + 1):
res = 1 + max(eggFloor[i-1][x-1], eggFloor[i][j-x])
if res < eggFloor[i][j]:
eggFloor[i][j] = res
# eggFloor[n][k] holds the result
return eggFloor[n][k]
# Driver program to test to pront printDups
n = 2
k = 36
print("Minimum number of trials in worst case with" + str(n) + "eggs and "
+ str(k) + " floors is " + str(eggDrop(n, k)))
# This code is contributed by Bhavya Jain
C＃
// A Dynamic Programming based C# Program
// for the Egg Dropping Puzzle
using System;
class GFG {
// A utility function to get maximum of
// two integers
static int max(int a, int b)
{
return (a > b) ? a : b;
}
/* Function to get minimum number of
trials needed in worst case with n
eggs and k floors */
static int eggDrop(int n, int k)
{
/* A 2D table where entry eggFloor[i][j]
will represent minimum number of trials
needed for i eggs and j floors. */
int[, ] eggFloor = new int[n + 1, k + 1];
int res;
int i, j, x;
// We need one trial for one floor and0
// trials for 0 floors
for (i = 1; i <= n; i++) {
eggFloor[i, 1] = 1;
eggFloor[i, 0] = 0;
}
// We always need j trials for one egg
// and j floors.
for (j = 1; j <= k; j++)
eggFloor[1, j] = j;
// Fill rest of the entries in table
// using optimal substructure property
for (i = 2; i <= n; i++) {
for (j = 2; j <= k; j++) {
eggFloor[i, j] = int.MaxValue;
for (x = 1; x <= j; x++) {
res = 1 + max(eggFloor[i - 1, x - 1],
eggFloor[i, j - x]);
if (res < eggFloor[i, j])
eggFloor[i, j] = res;
}
}
}
// eggFloor[n][k] holds the result
return eggFloor[n, k];
}
// Driver function
public static void Main()
{
int n = 2, k = 36;
Console.WriteLine("Minimum number of trials "
+ "in worst case with " + n + " eggs and "
+ k + "floors is " + eggDrop(n, k));
}
}
// This code is contributed by Sam007.
PHP
Javascript
输出
Minimum number of trials in worst case with 2 eggs and 36 floors is 8 输出 ：
Minimum number of trials in worst
case with 2 eggs and 36 floors is 8复杂度分析：
- 时间复杂度： O(n*k^2)。
其中“n”是鸡蛋的数量，“k”是楼层数，因为我们对每个鸡蛋使用嵌套的 for 循环 ‘k^2’ 次 - 辅助空间： O(n*k)。
由于大小为 ‘n*k’ 的二维数组用于存储元素。
方法 3：使用记忆化的动态规划。
C++
#include
using namespace std;
#define MAX 1000
vector> memo(MAX, vector (MAX, -1));
int solveEggDrop(int n, int k) {
if(memo[n][k] != -1) { return memo[n][k];}
if (k == 1 || k == 0)
return k;
if (n == 1)
return k;
int min = INT_MAX, x, res;
for (x = 1; x <= k; x++) {
res = max(
solveEggDrop(n - 1, x - 1),
solveEggDrop(n, k - x));
if (res < min)
min = res;
}
memo[n][k] = min+1;
return min + 1;
}
int main() {
int n = 2, k = 36;
cout< 输出
8作为练习，您可以尝试修改上述 DP 解决方案以打印所有中间楼层(用于最小试用解决方案的楼层)。
更有效的解决方案：鸡蛋掉落拼图(二项式系数和二元搜索解决方案)
含 2 个鸡蛋和 K 层的落蛋拼图
2 个鸡蛋和 100 层拼图
如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。