The following is a description of the instance of this famous puzzle involving n=2 eggs and a building with k=36 floors.

Suppose that we wish to know which stories in a 36-story building are safe to drop eggs from, and which will cause the eggs to break on landing. We make a few assumptions:

…..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 an egg breaks when dropped, then it would break if dropped from a higher floor.

…..If an egg survives a fall then it would survive a shorter fall.

…..It is not ruled out that the first-floor windows break eggs, nor is it ruled out that the 36th-floor do not cause an egg to break.

If only one egg is available and we wish to be sure of obtaining the right result, the experiment can be carried out in only one way. Drop the egg from the first-floor window; if it survives, drop it from the second floor window. Continue upward until it breaks. In the worst case, this method may require 36 droppings. Suppose 2 eggs are available. What is the least number of egg-droppings that is guaranteed to work in all cases?

The problem is not actually to find the critical floor, but merely to decide floors from which eggs should be dropped so that total number of trials are minimized.

Source: Wiki for Dynamic Programming

##
Recommended: Please solve it on “__PRACTICE__ ” first, before moving on to the solution.

__PRACTICE__**Dynamic Programming Solution**

## 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 entery 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. ` |

*chevron_right*

*filter_none*

**Output:**

Minimum number of trials in worst case with 2 eggs and 36floors is 8

Please refer complete article on Egg Dropping Puzzle | DP-11 for more details!

## Recommended Posts:

- C# Program for Naive algorithm for Pattern Searching
- C# Program for KMP Algorithm for Pattern Searching
- C# Program to print all permutations of a given string
- C# Program for Count Inversions in an array | Set 1 (Using Merge Sort)
- C# Program for Median of two sorted arrays of same size
- C# Program for Activity Selection Problem | Greedy Algo-1
- C# Program for Subset Sum Problem | DP-25
- C# Program for Dijkstra's shortest path algorithm | Greedy Algo-7
- C# Program for Maximum sum rectangle in a 2D matrix | DP-27
- C# Program for Largest Sum Contiguous Subarray
- C# Program for Maximum size square sub-matrix with all 1s
- C# Program for Minimum number of jumps to reach end
- C# Program for Cutting a Rod | DP-13
- C# Program for Longest Palindromic Subsequence | DP-12
- C# Program for Matrix Chain Multiplication | DP-8
- C# Program for Count set bits in an integer
- C# Program to Find the Number Occurring Odd Number of Times
- C# Program for Anagram Substring Search (Or Search for all permutations)
- C# Program to Count number of binary strings without consecutive 1's
- C# Program for Count ways to reach the n\'th stair