# Egg Dropping Puzzle

Suppose you have N eggs and you want to determine from which floor in a K-floor building you can drop an egg such that it doesn't break. You have to determine the minimum number of attempts you need in order find the critical floor in the worst case while using the best strategy.There are few rules given below.

- An egg that survives a fall can be used again.
- A broken egg must be discarded.
- The effect of a fall is the same for all eggs.
- If the egg doesn't break at a certain floor, it will not break at any floor below.
- If the eggs breaks at a certain floor, it will break at any floor above.

In this approach, we work on the same idea as described above **neglecting the case of calculating the answers to sub-problems again and again.**. The approach will be to make a table which will store the results of sub-problems so that to solve a sub-problem, it would only require a look-up from the table which will take **constant time**, which earlier took **exponential time**.

(1 + max( DP[i-1][j-1], DP[i][j-x] )).

This simulation will make things clear:

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’) = 2For 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

#include <bits/stdc++.h> using namespace std; int main() {int t; cin>>t; while(t--) { int e,f; cin>>e>>f; int dp[e+1][f+1]; for(int i=1;i<=e;i++) { dp[i][1]=1; dp[i][0]=0; } for(int i=1;i<=f;i++) { dp[1][i]=i; } for(int i=2;i<=e;i++) { for(int j=2;j<=f;j++) { dp[i][j] =INT_MAX; for(int x=1;x<=j;x++) { int rr=1+max(dp[i][j-x],dp[i-1][x-1]); if(rr<dp[i][j]) dp[i][j]=rr; } } } cout<<dp[e][f]<<endl; } //code return 0; }