Egg Drop 扔鸡蛋

假设有 n=2 个完全一样的鸡蛋， 有 k=36 层楼。 存在一个楼层 m，把鸡蛋从低于m的楼层扔下去的时候，鸡蛋不会摔破；把鸡蛋从高于等于m的楼层扔下去的时候，鸡蛋会摔破。题目要求，找出临界楼层m，并且扔鸡蛋的次数要做到最少。

思路：

最简单的方法是，从第 1 层往上，一层一层 的扔鸡蛋，直到鸡蛋摔碎。这样需要扔鸡蛋 m 次。

下面用递归的方法解决该问题。假设鸡蛋从 x 层扔下去。（1）如果鸡蛋摔破，那么还剩 n-1 个鸡蛋，临界楼层在 [1, x] 之间；（2）如果鸡蛋没破，那么还剩 n 个鸡蛋，临界楼层在 [k, x+1] z之间。 设 eggDrop(n,k) 是问题的解，那么递归表达式是

eggDrop(n,k) = 1+ min (   max( eggDrop(n-1, x-1), eggDrop(n, k-x) ) for all x in [1,k] )

代码如下：

# include <stdio.h>
# include <limits.h>
 
// A utility function to get maximum of two integers
int max(int a, int b) { return (a > b)? a: b; }
 
/* Function to get minimum number of trails needed in worst
  case with n eggs and k floors */
int eggDrop(int n, int k)
{
    // If there are no floors, then no trials needed. OR if there is
    // one floor, one trial needed.
    if (k == 1 || k == 0)
        return k;
 
    // We need k trials for one egg and k floors
    if (n == 1)
        return k;
 
    int min = INT_MAX, x, res;
 
    // Consider all droppings from 1st floor to kth floor and
    // return the minimum of these values plus 1.
    for (x = 1; x <= k; x++)
    {
        res = max(eggDrop(n-1, x-1), eggDrop(n, k-x));
        if (res < min)
            min = res;
    }
 
    return min + 1;
}
 
/* Driver program to test to pront printDups*/
int main()
{
    int n = 2, k = 10;
    printf ("\nMinimum number of trials in worst case with %d eggs and "
             "%d floors is %d \n", n, k, eggDrop(n, k));
    return 0;
}

动态规划的代码如下：

# include <stdio.h>
# include <limits.h>
 
// A utility function to get maximum of two integers
int max(int a, int b) { return (a > b)? a: b; }
 
/* Function to get minimum number of trails needed in worst
  case with n eggs and k floors */
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[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_MAX;
            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 program to test to pront printDups*/
int main()
{
    int n = 2, k = 36;
    printf ("\nMinimum number of trials in worst case with %d eggs and "
             "%d floors is %d \n", n, k, eggDrop(n, k));
    return 0;
}