Eggs dropping puzzle | Set 2
Last Updated :
17 Nov, 2023
Given N eggs and K floors, the task is to find the minimum number of trials needed, in the worst case, to find the floor below which all floors are safe. A floor is safe if dropping an egg from it does not break the egg. Please refer n eggs and k floors for more insight.
Examples:
Input: N = 2, K = 10
Output: 4
Explanation:
The first trial was on the 4th floor. Two cases arise after this:
- If the egg breaks, we have one egg left, so we need three more trials.
- If the egg does not break, the next try is from the 7th floor. Again, two cases arise.
Input: N = 2, K = 100
Output: 14
Prerequisites: Egg Dropping Puzzle
Approach: Consider this problem in a different way:
Let dp[x][n] is the maximum number of floors that can be checked with given n eggs and x moves.
Then the equation is:
- If the egg breaks, then we can check dp[x – 1][n – 1] floors.
- If the egg doesn’t break, then we can check dp[x – 1][n] + 1 floors.
Since we need to cover k floors, dp[x][n] >= k.
dp[x][n] is similar to the number of combinations and it increases exponentially to k
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int eggDrop( int n, int k)
{
vector<vector< int > > dp(k + 1, vector< int >(n + 1, 0));
int x = 0;
while (dp[x][n] < k) {
x++;
for ( int i = 1; i <= n; i++)
dp[x][i] = dp[x - 1][i - 1] + dp[x - 1][i] + 1;
}
return x;
}
int main()
{
int n = 2, k = 36;
cout << eggDrop(n, k);
return 0;
}
|
Java
class GFG
{
static int eggDrop( int n, int k)
{
int dp[][] = new int [k + 1 ][n + 1 ];
int x = 0 ;
while (dp[x][n] < k)
{
x++;
for ( int i = 1 ; i <= n; i++)
dp[x][i] = dp[x - 1 ][i - 1 ] +
dp[x - 1 ][i] + 1 ;
}
return x;
}
public static void main(String args[])
{
int n = 2 , k = 36 ;
System.out.println( eggDrop(n, k));
}
}
|
Python3
def eggDrop(n, k):
dp = [[ 0 for i in range (n + 1 )] for
j in range (k + 1 )]
x = 0 ;
while (dp[x][n] < k):
x + = 1 ;
for i in range ( 1 , n + 1 ):
dp[x][i] = dp[x - 1 ][i - 1 ] + \
dp[x - 1 ][i] + 1 ;
return x;
if __name__ = = '__main__' :
n = 2 ; k = 36 ;
print (eggDrop(n, k));
|
C#
using System;
class GFG
{
static int eggDrop( int n, int k)
{
int [,]dp = new int [k + 1, n + 1];
int x = 0;
while (dp[x, n] < k)
{
x++;
for ( int i = 1; i <= n; i++)
dp[x, i] = dp[x - 1, i - 1] +
dp[x - 1, i] + 1;
}
return x;
}
public static void Main(String []args)
{
int n = 2, k = 36;
Console.WriteLine(eggDrop(n, k));
}
}
|
Javascript
<script>
function eggDrop(n, k)
{
let dp = new Array();
for (let i = 0; i < k + 1; i++){
dp.push( new Array(n + 1).fill(0))
}
let x = 0;
while (dp[x][n] < k) {
x++;
for (let i = 1; i <= n; i++)
dp[x][i] = dp[x - 1][i - 1] + dp[x - 1][i] + 1;
}
return x;
}
let n = 2, k = 36;
document.write(eggDrop(n, k));
</script>
|
Time Complexity: O(N * K)
Auxiliary Space: O(N * K)
Efficient Approach : Space Optimization
To optimize the space complexity of the above approach, we can observe that each entry dp[x][i] only depends on the previous row dp[x-1][i-1] and dp[x-1][i]. Therefore, we can use a 1D array instead of a 2D array to store the values of the current row and update it iteratively.
Step-by-step approach:
- Initialize a 1D vector dp of size n+1 with all elements set to 0.
- Initialize a variable x to 0.
- Enter a loop until the number of trials needed for n eggs is less than k.
- Inside the loop, iterate from n down to 1.
- Update the dp array at index i with the sum of the values at dp[i-1], dp[i], and 1.
- Increment x.
- Repeat the loop until the number of trials needed for n eggs is greater than or equal to k.
- Return the value of x.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int eggDrop( int n, int k)
{
vector< int > dp(n + 1, 0);
int x = 0;
while (dp[n] < k) {
x++;
for ( int i = n; i >= 1; i--)
dp[i] = dp[i - 1] + dp[i] + 1;
}
return x;
}
int main()
{
int n = 2, k = 36;
cout << eggDrop(n, k);
return 0;
}
|
Java
import java.util.*;
public class GFG {
static int eggDrop( int n, int k)
{
int [] dp = new int [n + 1 ];
int x = 0 ;
while (dp[n] < k) {
x++;
for ( int i = n; i >= 1 ; i--) {
dp[i] = dp[i - 1 ] + dp[i] + 1 ;
}
}
return x;
}
public static void main(String[] args)
{
int n = 2 , k = 36 ;
System.out.println(eggDrop(n, k));
}
}
|
Python3
def eggDrop(n, k):
dp = [ 0 ] * (n + 1 )
x = 0
while dp[n] < k:
x + = 1
for i in range (n, 0 , - 1 ):
dp[i] = dp[i - 1 ] + dp[i] + 1
return x
n = 2
k = 36
print (eggDrop(n, k))
|
C#
using System;
class Program
{
static int EggDrop( int n, int k)
{
int [] dp = new int [n + 1];
int x = 0;
while (dp[n] < k)
{
x++;
for ( int i = n; i >= 1; i--)
dp[i] = dp[i - 1] + dp[i] + 1;
}
return x;
}
static void Main()
{
int n = 2;
int k = 36;
Console.WriteLine(EggDrop(n, k));
}
}
|
Javascript
function eggDrop(n, k) {
let dp = new Array(n + 1).fill(0);
let x = 0;
while (dp[n] < k) {
x++;
for (let i = n; i >= 1; i--)
dp[i] = dp[i - 1] + dp[i] + 1;
}
return x;
}
let n = 2, k = 36;
console.log(eggDrop(n, k));
|
Time Complexity: O(N * K)
Auxiliary Space: O(N)
Share your thoughts in the comments
Please Login to comment...