Understanding Egg Drop Algorithm for more than two eggs. - algorithm

Question

http://datagenetics.com/blog/july22012/index.html
I am using the mentioned link to understand the eggdrop problem. I have also looked at code online which I understand to decent extent (the recursion is a bit confusing) but I can't seem to understand a few main things about this egg drop problem.
Suppose we have 100 floors
For 2 eggs we say we start at 14 and then go to 14 + (14-1). I understand why we do this to keep the worse case time uniform and all. However, where will we start for three eggs? The formula shows that 3 eggs will have a max of 9 tries in the worst case. Obviously we don't start from 9 because going 9 + ( 9 - 1 ) doesn't give us a consisten 9 trials across 100 so where do we start for 3? Not only that but how do we figure this out?
It seems like for 3 eggs, we run a few trials until the problem degenerates into 2 eggs and x amount of floors. Conceptually this makes sense but I don't understand how to visualize or implement this
I have to find the sequence of tries in a worst case scenario and implement it which is why I want to visualize the tries.
I hope this is clear. It is the first bullet of mine that is my main issue. Please let me know if I'm missing out any info and I'll edit it.

Answer 1

The equation n(n+1)/2 = F can only be used to solve the min worst case number of drops in the case of 2 eggs. Here also happens to be one of the floors you can drop the 1st egg from because of the uniformity you mentioned. You know you can drop from the 14th floor because if it cracks you'll have, at worst, 13 more drops. But if it doesn't crack and you go up 13 floors and it cracks, you will have at worst 12 more drops to go with 2 under your belt already. With this pattern you can see that by dropping the egg from nth floor, then n+(n-1) floor, then n+(n-1)+(n-2) floor your worst case is staying the same at each threshold.
This is what you want to achieve regardless of how many eggs you start with, but finding an optimal floor (n) which makes this condition true (which actually can be expressed as a range as #Amit pointed out) can't be calculated with a closed series like it can for 2 eggs. It is important to note that even in the case of (n+1)n = F, n is just one of many answers for the possible first floor value. We conveniently say it is the answer, perhaps carelessly, because we can prove it to be true using a relatively simple series.
So let's use a more general approach to estimate the minimum worst case number of drops and then see at which floors we know that this can be achieved. Let's say we have function, g(floors, eggs), which returns the minimum worst case egg drops needed for a particular amount of floors. We can say with confidence that if eggs = 1, the worst case scenario is that we will have to drop the egg from every floor to find the threshold, so g(floors, 1) = floors is true for any value of floors. We also know that if we have 1 floor to test it will always only require one drop so g(1, eggs) = 1. Beyond these two cases we know the following:
g(floors, eggs) = Min(n = 1->floors : 1 + max(g(n-1,e-1),g(floors-n, e)))
Why does it work? Well given an amount of total floors, one must go through every single one and see what the worst case is for cracking the egg at each. This is done by comparing worst case if it cracks, or g([current floor]-1, eggs-1), with worst case if it doesn't crack, or g(floors-[current floor], eggs).
The maximum of these two values will be the worst case scenario for that particular floor. If we track a global minimum of each of these maxima, we will find the lowest drops required for the worst case. The floor(s) at which this happens is the optimal floor to drop the egg at. Now let's plug in eggs = 2 in that function to get a better feeling as to why this works, and why we can also represent the min worst case number of drops when starting with 2 eggs as a series as well.
When we have precisely 2 eggs we will always be comparing g([current floor]-1, 1) with g(floors-[current floor], 2). This makes things a bit easier because we know exactly what the worst case is if we crack the egg at current floor:
*worst case drops required* = g(cf-1, 1) + 1 = 1 + (cf-1)
note-here we add the 1 because we have already done 1 drop by the time we can test the remaining floors below.
We also know that the two functions we are comparing at each floor (cf) are monotonically going in two different directions for any fixed number of total floors F. This must be true because:
g(cf+d, 1) > g(cf, 1) for any positive cf and d so this function is increasing as you increase cf.
g(F-(cf+d),2) < g(F-cf,2), thus this function is always decreasing as you increase cf.
The above is important because it makes us realize that the minimum max of these two functions will happen at a floor (let's call it optimal floor, of) where they return values that are closest to one another, one could even dare to say equal to each other! Using this we can approximate that the minimum occurs when:
g(of1-1, 1) ~= of1-1 ~= g(F- of1, 2) ~= 1+(of2-1) ~= 1+ g(F- of1 - of2, 2) ~= 2+(of3-1) ~=.....~= of2 --> the value furthest on the right represents the worst case if the egg doesn't crack at any of the optimal thresholds, then we will have used up of2 number of drops to get to that point, not counting the very first drop.
where of1 is the theoretical floor where the first drop can occur to minimize the worst case and of1+of2 is where the second drop must occur (given failure to crack at of1), all the way up until of1 + of2...+ofn = F. Let's now examine the relationship between of1 and of2:
(of1-1) = 1+(of2-1), so of2 = of1-1
similarly
of3 = of2 -1 = of1 - 2
finally we can say that in general
ofn = of1-(n-1)
We know that if we have gone through all threshold floors except for the last, and none cracked the egg, then we are on our of1th drop.
ofof1 = of1-(of1-1) =1 => this element is the last in our series
The series, of1 + of2...+ofn can be written as of1 + (of1-1) + (of1-2) +....+1 = F which we know can be expressed as (of1)(of1+1)/2 = F. This makes finding both the minimum worst case number of drops and the optimal floor to drop the first egg a simple exercise of plugging in F into this formula.
Okay now let's use the same function when eggs equals three! Well unfortunately it turns out that you hit a wall in the very first step. Remember when we were still comparing g([current floor]-1, eggs-1) with g(floors-[current floor], eggs)? Well let's say eggs = 3 now so you are comparing g(floors-[current floor], 3) and g([current floor]-1, 2).
We cannot reduce any of these functions into a series with a closed form solution as the function
g(F - cf, 3)
requires at least one level of recursion to solve so whatever we reduce it to will always have a term with g function in it. On the other hand if we try to utilize the fact that for any
g(f-1, 2)
there exists an n where (n+1)n/2 = f-1, where n is the minimum worst case number of drops.
If we rearrange (n+1)n/2 = f-1 to n = 1/2(sqrt(8f-7)-1) = g(f-1, 2)
we could potentially try to set g(of1-1, 2) equal to 1+g(of2-1, 2) to find of2 as a function of of1, similarly to how we found of2 expressed in terms of of1 when were starting with 2 eggs. If you recall we put all "optimum" floors for drops, expressed in terms of the optimum floor for the first drop, in a series that happened to have a closed form solution. With 3 eggs we run out of luck as this results in an "ugly" series with no way of solving without recursion. This is unlike in the case where we were starting with 2 eggs because we were able to reduce g(cf-1, 1) + 1 into just 1 + (cf-1). This helped us build the series which did have a closed form solution.
Therefore there is no nifty derivation to use to find the optimal first drop like there is in the case of 2 eggs. Below I wrote a short algo that outputs both min worst case number of drops and optimal floor for first drop (often times it can be more than one but I always return the last). Once you put in a value other than 2 for e you can notice that these will not necessarily equal one another.
var optimumFloorForFirstDrop = 0;
var F = 24;
console.log("Minimum worst case number of drops: " +findBestWorstCase(F,3) + ", optimum floor for first drop: "+ optimumFloorForFirstDrop);
function findBestWorstCase(n, e){
//if we have 0 or 1 floors or one egg then return the number of floor...this is pretty intuitive
if(n < 2 || e == 1) return n;
//we want to go through every floor and keep track of the minimum for a particular n of the max function below
var min = n;
for(var i = 1; i <= n; i++){
var tmpMax = 1 + Math.max(findBestWorstCase(i-1, e-1),findBestWorstCase(n-i, e));
if(tmpMax <= min){
min = tmpMax;
if(n==F) optimumFloorForFirstDrop = i;
}
}
return min;
}

Answer 2

Let's examine a few examples first:
If you have 1 egg, how many throws do you need for a 2 floors building? 3 floors? 4?
Obviously that's simple. You need 2, 3 and 4 throws, respectively, and generally, n throws.
What if you have 2 eggs? How many throws for 2 floors? 3? 4?
Obviously 2 throws for 2 floors... 3 is interesting though. If you throw an egg from the 2nd floor, and it doesn't break, you throw it from the 3rd floor and you know the answer (it either breaks on the 3rd floor, or doesn't at all). If the first egg breaks on the 2nd floor throw, you throw the other egg from the first floor and again you know the answer (it either breaks on the 1st floor and that's the answer, or it doesn't and the answer is the 2nd floor). Ha... so only 2 throws for 3 floors. But that doesn't work for the 4th floor and we need another throw. That extra throw can "buy us" more than just one floor. It will actually get us to the 6th floor (we'll soon see how that works).
It also turns out that having more eggs won't make any difference for a 6 floor building or less.
Suppose we know how many floors we can cover with m-1 eggs and n-1 throws, let's call that h. If we have m eggs and n throws, our optimal strategy would be to through the first egg from the h+1th floor - that's the highest floor we can go for. If the egg breaks, we have enough eggs (m-1) and enough throws (n-1) to find the answer in the remaining h floors. Our next move if the egg doesn't break is to go up enough floors so that we're covered by (m, n-1) and keep doing that till we have no throws left. This way we will achieve the maximum coverage with any combination of eggs and throws.
That explains our optimal strategy, but we haven’t defined how many floors will (m, n) cover. That’s quite simple though: (m-1, n-1) will cover some h floors, the (m, n) throw itself will account for the h+1 floor, and the remaining throws will allow for additional (m, n-1) floors.
The modeling of the problem should be quite clear by now, and we can define a simple recursive function to calculate the maximal covered height:
function maxHeightByEggThrows(eggs, throws) {
if(eggs === 0 || throws === 0)
return 0;
return maxHeightByEggThrows(eggs - 1, throws - 1) + 1 +
maxHeightByEggThrows(eggs, throws - 1);
}
And this works flawlessly, but it’s a poor, ineffective implementation. Let’s try DP:
function maxHeightByEggThrowsDP(eggs, throws) {
let eggThrows = [[]];
for(let i = 0; i < throws; i++) {
// A single egg can cover has many floors has throws are allowed
eggThrows[0].push(i + 1);
}
for(let i = 1; i < eggs; i++) {
// Any number of eggs can only cover 1 floor with a single throw
eggThrows.push([1]);
}
for(let i = 1; i < throws; i++) {
for(let j = 1; j < eggs; j++) {
eggThrows[j][i] = eggThrows[j - 1][i - 1] + eggThrows[j][i - 1] + 1;
}
}
return eggThrows[eggs - 1][throws - 1];
}
This doesn't look as nice, but it's much better for performance reasons, and, we can use such an implementation to return the whole table and display it:
function maxHeightByEggThrowsDP(eggs, throws) {
let eggThrows = [[]];
for (let i = 0; i < throws; i++) {
// A single egg can cover has many floors has throws are allowed
eggThrows[0].push(i + 1);
}
for (let i = 1; i < eggs; i++) {
// Any number of eggs can only cover 1 floor with a single throw
eggThrows.push([1]);
}
for (let i = 1; i < throws; i++) {
for (let j = 1; j < eggs; j++) {
eggThrows[j][i] = eggThrows[j - 1][i - 1] + eggThrows[j][i - 1] + 1;
}
}
return eggThrows;
}
const eggs = 10;
const throws = 15;
let eggThrows = maxHeightByEggThrowsDP(eggs, throws);
// display our data (boilerplate code)
// add a "row header" so we can read the egg count
eggThrows.forEach((row, i) => row.unshift(i + 1));
d3.select('#eggThrows>tbody').selectAll('tr').data(eggThrows).enter().append('tr').selectAll('td').data(d => d).enter().append('td').text(t => t);
d3.select('#throwsHeader').attr('colSpan', throws);
#eggThrows > thead td {
padding: 5px;
background-color: #404040;
color: white;
}
#eggThrows > tbody td {
padding: 5px;
background-color: #C0C0C0;
}
#eggThrows > tbody td:first-child {
background-color: #C0FF30;
}
<script src="https://cdnjs.cloudflare.com/ajax/libs/d3/3.4.11/d3.min.js"></script>
<table id="eggThrows"><thead><tr><td>Eggs</td><td id="throwsHeader">Throws</td></tr></thead><tbody></tbody></table>
So we know the maximum height, but we wanted the first throw floor... It turns out there are multiple options. For example, we can now see that in the classic "2 eggs 14 throws" case, we can actually get an answer for 105 floors, not just 100. We also know that 2 eggs and 13 throws covers 91 floors, so we could throw the first egg from the 9th floor and still manage to find a solution within 14 throws.
And now we can answer the question:
The first floor to throw from is not higher than (maxHeightByEggThrows(m-1, n-1) + 1) and not lower than ([building height] - maxHeightByEggThrows(m, n-1))
(for 3 eggs and 100 floors, this is between the 8th and 37th floors)

Answer 3

This problem can be solved with following 3 approaches (that I know) :
Dynamic Programming
Solution using Binary Search Tree
Solution by obtaining the direct mathematical formula for maximum number of floors that can be tested or covered with given number of eggs and given number of drops
Let me first define some symbols that are used in analysis done afterwards :
e = number of eggs
f = number of floors in building
n = number of egg drops
Fmax(e, n) = maximum number of floors that can be tested or covered with e eggs and n drops
The crux for dynamic programming approach lies in following recursive formula for Fmax:
Fmax(e, n) = 1 + Fmax(e-1, n-1) + fmax(e, n-1)
And the crux for obtaining the direct mathematical formula for Fmax lies in following recursive formula for Fmax:
Fmax(e, n) = { ∑Fmax(e-1,i) for i = 1 to n } - Fmax(e-1, n) + n
Alternative solution using Binary Search Tree (BST) is also possible for this problem. In order to facilitate our analysis, let us draw BST with slight modifications as follows:
1. If egg breaks then child node is drawn on left down side
2. If egg does not break then child node is drawn straight down side
If we draw BST with above kind of representation then width of the BST represents the number of eggs.
Any BST with f number of nodes, drawn with above kind of representation and subjected to the constraint width of BST <= e (number of eggs) is a solution but it may not be the optimal solution.
Hence obtaining the optimal solution is equivalent to obtaining the arrangement of nodes in BST with minimum height subjected to the constraint: width of BST <= e
For more details about all the above 3 approaches, check my blog at: 3 approaches for solving generalized egg drop problem

Answer 4

Here is the algorithm which have implemented in swift(This includes concept of all previous algorithm):-
//Here n is number of eggs and k is number of floors
func eggDrop(_ n: Int, _ k: Int) -> Int {
var eggFloor: [[Int]] = Array(repeating:Array(repeating: 0, count: k+1),count: n+1)
if k == 1 {
return k
}
for i in 1...n {
eggFloor[i][1] = 1
eggFloor[i][0] = 0
}
for j in 1...k {
eggFloor[1][j] = j
}
for i in 2...n {
for j in 2...k {
eggFloor[i][j] = Int(INT_MAX)
for x in 1...j {
let attempts = 1 + max(eggFloor[i-1][x-1], eggFloor[i][j-x])
if attempts < eggFloor[i][j] {
eggFloor[i][j] = attempts
}
}
}
}
return eggFloor[n][k]
}