# Egg dropping problem using Dynamic Programming (DP)

In this article, we are going to implement a C++ program to solve the Egg dropping problem using dynamic programming (DP).
Submitted by Ritik Aggarwal, on December 13, 2018

Problem statement: You are given N floor and K eggs. You have to minimize the number of times you have to drop the eggs to find the critical floor where critical floor means the floor beyond which eggs start to break. Assumptions of the problem:

1. If egg breaks at ith floor then it also breaks at all greater floors.
2. If egg does not break at ith floor then it does not break at all lower floors.
3. Unbroken egg can be used again.

Note: You have to find minimum trials required to find the critical floor not the critical floor.

Constraints:

```    1 <= N <= 1000
1 <= K <= 100
```

Example 1:

```    Input:
4
2

Output:
Number of trials when number of eggs is 2 and number of floors is 4: 3
```

Example 2:

```    Input:
36
2

Output:
Number of trials when number of eggs is 2 and number of floors is 36: 8
```

Explanation of the problem:

For the Input 1,

Case 1. Drop at first floor:

1. Egg does not break:
If egg does not break then we have three floors left and two eggs. We can either choose 2nd or 3rd floor and proceed similarly but we can easily see we have to do atleast 3 trials.
2. Egg breaks:
If egg breaks then we found the critical floor in only 1 trial.

In case 1, the worst possibility is that egg does not break so trials will be 3 for case 1.

Case 2. Drop at second floor:

1. Egg breaks:
We are left with one egg and we have to check only 1 floor so number of trials 2.
2. Egg does not break:
We still have two eggs and two floors to check we have to check one by one on these floors so trials needed are 3.

So for case 2 together the worst possibility is 3.

In the end we have to find the minimum of case 1, case 2, case 3, case 4.

Note: Dropping from 3rd and 4th floor is same as dropping from 2nd and 1st floor respectively only difference is that subcases A and B just gets swapped.

Algorithm:

1. Create a 2D dp matrix where jth cell of ith row represents the minimum number of trials needed to check i floors using j eggs.
2. If there are 0 eggs then there are 0 trials so initializing all cell corresponding to this situation.
3. If there are 1 egg then we have to drop egg at every floor so the number of trials is number of floors.
4. If there are 0 floors so there are 0 trials and if there is one floor there is only one trial.
5. Start filling the dp matrix from egg = 2 && floors = 2.
6. We have to choose a floor x between the 1 – floor and then find cases when egg breaks at xth floor and egg do not break at xth floors (A and B subparts of cases).
7. We have to take the maximum of these A and B subparts as we are taking worst case possible. Also, we will also add one to it as one trial is also needed to check xth floor.
8. Taking the minimum of answers of all such x's and storing at my particular number of floors and number of eggs.

The time complexity of the above code is O(N * K * K).

## C++ program for Egg dropping problem using Dynamic Programming (DP)

```#include <iostream>
#include <limits.h>
using namespace std;

int eggDrop(int floors, int eggs){
int dp[floors + 1][eggs + 1] = {0};
// intializing with some cases
// case 1. when there are 0 floors
for(int egg = 0;egg<=eggs;egg++){
dp[0][egg] = 0;
}
// case 2. when there are only 1 floor so there
// are only 1 way only check the first floor
for(int egg = 0;egg<=eggs;egg++){
dp[1][egg] = 1;
}
// case 3. when there are 0 eggs
for(int floor = 0;floor <=floors;floor++){
dp[floor][0] = 0;
}
// case 4. when there are 1 egg then we have to
// check every floor so our answer would be number of
// floors
for(int floor = 0;floor <= floors;floor++){
dp[floor][1] = floor;
}
// we will start filling dp matrix from
// floor = 2 && egg = 2
for(int egg = 2;egg<=eggs;egg++){
for(int floor = 2;floor<=floors;floor++){
// choosing an ith floor between 1 - floor
int mini = INT_MAX;
for(int i = 1;i<=floor;i++){
// dp[i - 1][egg-1] means to find the answer when
// the egg is broken at ith floor
// dp[floor - i][egg] means to find the answer
// when the egg is not broken at ith floor
int ans = max(dp[i-1][egg-1], dp[floor - i][egg]);
// by trying to check the floor i have used one trial
ans++;
// taking the minimum of all possible floor
// possible between 1 - floor
mini = min(mini, ans);
}
dp[floor][egg] = mini;
}
}
return dp[floors][eggs];
}
// driver program
int main() {
int floors, eggs;
cin >> floors >> eggs;
cout<<"number of trials when number of eggs is " << eggs;
cout<<" and number of floors is " << floors;
cout<<": "  << eggDrop(floors,eggs);
return 0;
}
```

Output

```4
2
number of trials when number of eggs is 2 and number of floors is 4: 3
```

What's New

Top Interview Coding Problems/Challenges!

Languages: » C » C++ » C++ STL » Java » Data Structure » C#.Net » Android » Kotlin » SQL
Web Technologies: » PHP » Python » JavaScript » CSS » Ajax » Node.js » Web programming/HTML
Solved programs: » C » C++ » DS » Java » C#
Aptitude que. & ans.: » C » C++ » Java » DBMS
Interview que. & ans.: » C » Embedded C » Java » SEO » HR
CS Subjects: » CS Basics » O.S. » Networks » DBMS » Embedded Systems » Cloud Computing
» Machine learning » CS Organizations » Linux » DOS
More: » Articles » Puzzles » News/Updates