# Super Egg Drop in C++

C++Server Side ProgrammingProgramming

#### C in Depth: The Complete C Programming Guide for Beginners

45 Lectures 4.5 hours

#### Practical C++: Learn C++ Basics Step by Step

Most Popular

50 Lectures 4.5 hours

#### Master C and Embedded C Programming- Learn as you go

Best Seller

66 Lectures 5.5 hours

Suppose we have given K eggs, and we have a building with N floors from 1 to N. Now each egg is identical in function, and if an egg breaks, we cannot drop it again.

There exists a floor F with between 0 and N such that any egg dropped at a floor higher than F will break, and any egg dropped at or below floor F will not break. In each move, we may take an egg and drop it from any floor X. The X is in range 1 to N.

Our goal is to know with certainty what the value of F is. So, what will be the minimum number of moves that we need to know with certainty what F is, regardless of the initial value of F?

So, if the input is like K = 2 and N = 6, then the output will be 3.

To solve this, we will follow these steps −

• Define one 2D array dp

• Define a function solve(), this will take K, N,

• if N <= 1, then −

• return N

• if K is same as 1, then −

• return N

• if dp[K, N] is not equal to -1, then −

• return dp[K, N]

• ret := N, low := 0, high := N

• while low <= high, do −

• left := 1 + solve(K - 1, mid - 1)

• right := 1 + solve(K, N - mid)

• ret := minimum of ret and maximum of left and right

• if left is same as right, then −

• Come out from the loop

• if left < right, then:

• low := mid + 1

• otherwise high := mid - 1

• return dp[K, N] = ret

• Frm the main method do the following −

• dp := Create one 2D array (K + 1) x (N + 1), fill this with -1

• return solve(K, N)

Let us see the following implementation to get better understanding −

## Example

Live Demo

#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
vector<vector<int>> dp;
int solve(int K, int N) {
if (N <= 1)
return N;
if (K == 1)
return N;
if (dp[K][N] != -1)
return dp[K][N];
int ret = N;
int low = 0;
int high = N;
while (low <= high) {
int mid = low + (high - low) / 2;
int left = 1 + solve(K - 1, mid - 1);
int right = 1 + solve(K, N - mid);
ret = min(ret, max(left, right));
if (left == right)
break;
if (left < right) {
low = mid + 1;
} else
high = mid - 1;
}
return dp[K][N] = ret;
}
int superEggDrop(int K, int N) {
dp = vector<vector<int>>(K + 1, vector<int>(N + 1, -1));
return solve(K, N);
}
};
main(){
Solution ob;
cout << (ob.superEggDrop(2,6));
}

## Input

2, 6

## Output

3
Updated on 04-Jun-2020 08:47:29