动态规划实例（十一）：扔鸡蛋问题

    两个软硬程度一样但未知的鸡蛋，它们有可能都在一楼就摔碎，也可能从一百层楼摔下来没事。现有座36层的建筑，要你用这两个鸡蛋确定哪一层是鸡蛋可以安全落下的最高位置，可以摔碎两个鸡蛋，要求用最少的测试次数。
      1  如果你从某一层楼扔下鸡蛋，它没有碎，则这个鸡蛋你可以继续用
      2  如果这个鸡蛋摔碎了，则你可以用来测试的鸡蛋减少一个
      3  所有鸡蛋的质量相同（都会在同一楼层以上摔碎）
      4  对于一个鸡蛋，如果其在楼层i扔下的时候摔碎了，对于任何不小于i的楼层，这个鸡蛋都会被摔碎
      5  如果在楼层i扔下的时候没有摔碎，则对于任何不大于i的楼层，这颗鸡蛋也不会摔碎
      6  从第1层扔下，鸡蛋不一定完好，从第36层扔下，鸡蛋也不一定会摔碎。
   实际上，我们的终极目的是要找出连续的两层楼i，i+1。在楼层i鸡蛋没有摔碎，在楼层i+1鸡蛋碎了，问题的关键之处在于，测试之前，你并不知道鸡蛋会在哪一层摔碎，你需要找到的是一种测试方案，这种测试方案，无论鸡蛋会在哪层被摔碎，都至多只需要m次测试，在所有这些测试方案中，m的值最小。
   为什么是两个鸡蛋呢？如果只有一个鸡蛋，我们只能从下往上一层一层的测试。对于2个鸡蛋，比较容易想到的就是使用二分的方法，现在18层测试，如果这颗碎了，则你从第1层，到第17层，依次用第2颗鸡蛋测试。否则继续用两个鸡蛋测试上半部分的楼层，最多需要18次测试，减少了一半。看似是个不错的方法，可惜正确答案是8次。
   其实，对于任何连续的M层，这M层在下面或在下面，对于这M层来说需要的测试次数都没有影响。因此，可以把这个问题一般化，考虑n个鸡蛋 k层楼，记为E(n,k)。解决的办法是试着从每一层掉落一个鸡蛋（从1到k）并递归计算需要在最坏的情况下需要的最小测试次数。考虑用程序来穷举所有情况找到答案。

   1) 最优子结构
     当我们从一个楼层x扔下鸡蛋时，有可能出现两种情况（1）鸡蛋破（2）鸡蛋不破。
        1）鸡蛋破，那么我们只需要用剩下的鸡蛋测试 x层以下的楼层; 所以问题简化为x-1层和n-1个鸡蛋
        2）如果鸡蛋没有破，那么我们只需要检查比x较高的楼层; 所以问题简化为 k-x 和n个鸡蛋。
    最优子结构可以表示为：
    view source
    k ==> 楼层数
    n ==> 鸡蛋数
      eggDrop(n, k) ==>最少需要的测试次数(考虑所有情况)

      eggDrop(n, k) = 1 + min{max(eggDrop(n - 1, x - 1), eggDrop(n, k - x)): x 属于 {1, 2, ..., k}}

具体实例及实现代码如下所示：

/**
 * @Title: EggDroppingPuzzle.java
 * @Package dynamicprogramming
 * @Description: TODO
 * @author peidong
 * @date 2017-6-12 上午8:43:42 
 * @version V1.0
 */
package dynamicprogramming;

/**
 * @ClassName: EggDroppingPuzzle
 * @Description: 扔鸡蛋问题
 * @date 2017-6-12 上午8:43:42 
 *
 */

public class EggDroppingPuzzle {

    /**
     *
     * @Title: eggDroppingRecursion
     * @Description: 递归方式求解问题
     * @param n  鸡蛋数
     * @param k  楼层数
     * @return
     * @return int
     * @throws 上面的程序问题是复杂度太大 O(2^k)。如果k=36的话，基本是跑不出结果。
     */
    public static int eggDroppingRecursion(int n, int k){
        //边界条件判断
        if(k == 1 || k == 0)
            return k;
        //如果只有一个鸡蛋，最坏的情况下是k次测试，一层层
        if(n == 1)
            return k;

        int min = 65535;
        int res;

        //考虑从第一层到第k层扔下鸡蛋的所有情况的最小结果
        for(int i = 1; i <= k; i++){
            res = Math.max(eggDroppingRecursion(n-1, i-1), eggDroppingRecursion(n, k-i));
            if(res < min)
                min = res;
        }
        return min+1;
    }
    //上面的程序问题是复杂度太大 O(2^k)。如果k=36的话，基本是跑不出结果。

    public static int eggDropping(int n, int k){
        //构建状态转移矩阵
        int[][] tc = new int[n+1][k+1];
        int res;

        //初始化状态转移矩阵
        for(int i = 0; i <= n; i++){
            tc[i][1] = 1;
            tc[i][0] = 0;
        }

        //只有一个鸡蛋时
        for(int j = 1; j <= k; j++){
            tc[1][j] = j;
        }

        //构建状态转移矩阵
        for(int i = 2; i <= n; i++){
            for(int j = 2; j <= k; j++){
                tc[i][j] = 65535; //默认值
                for(int x = 1; x <= j; x++){
                    res = 1 + Math.max(tc[i-1][x-1], tc[i][j-x]);
                    if(res < tc[i][j])
                        tc[i][j] = res;
                }
            }
        }
        return tc[n][k];
    }

    /**
     * @Title: main
     * @Description: 测试
     * @param args
     * @return void
     * @throws
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub

        int n = 2;
        int k = 5;
        int m = 36;

        System.out.println("利用递归求解扔鸡蛋问题结果为：" + eggDroppingRecursion(n, k));
        System.out.println("利用动态规划求解扔鸡蛋问题结果为：" + eggDropping(n, k));
        System.out.println("利用动态规划求解扔鸡蛋问题结果为：" + eggDropping(n, m));

    }

}