21.解闷算法-双蛋问题（dp）

双蛋问题：

public class Egg {

 
    public static void main(String[] args) {
        int[][] a = new int[1][2];
        System.out.println(a.length);//1
        new Egg().dp(100);
    }

    //t层楼，2个蛋
    public void dp(int t) {
        //t层楼，n个鸡蛋最多需要多少次
        int[][] a = new int[t + 1][3];

        //楼层数量一直在变化，只有1个鸡蛋时候的扔法
        for (int i = 1; i < a.length; i++) {
            a[i][1] = i;
        }
        //只有1层楼，鸡蛋数量一直在变化时候的扔法
        for (int i = 1; i < a[0].length; i++) {
            a[1][i] = 1;
        }
        //从只有2层楼的情况开始
        for (int i = 2; i <= t; i++) {

            int result = Integer.MAX_VALUE;
            //从第一层开始扔，一直有t中扔法
            for (int j = 1; j < i; j++) {
                //鸡蛋碎了，还有j-1层楼(从第一层到第j层)，1个鸡蛋
                int timesA = a[j - 1][1] + 1;
                //鸡蛋没碎,还有i-j层楼，2个鸡蛋
                int timesB = a[i - j][2] + 1;
                //楼层最不容易验出来的情况下所需要扔的最大次数
                int bad = Math.max(timesA, timesB);
                //记录选取最好的扔法
                result = Math.min(bad, result);
            }
            a[i][2] = result;
        }
    }
}

n蛋问题：

/**
 * N个蛋，T层楼高
 * 第一个蛋扔在第K层的时候
 * 1个蛋1层楼
 */
public class Egg {

    //t层楼，n个蛋
    public void dp(int t, int n) {
        //t层楼，n个鸡蛋最多需要多少次
        int[][] a = new int[t + 1][n + 1];
        //1层楼，蛋的数量在变化
        for (int i = 1; i <= n; i++) {
            a[1][i] = 1;
        }
        //1个蛋，楼层在变化
        for (int j = 1; j <= t; j++) {
            a[j][1] = j;
        }
        //楼层在升高
        for (int t1 = 2; t1 < t + 1; t1++) {
            //蛋的数量在增加
            for (int n1 = 2; n1 < n + 1; n1++) {
                int min = Integer.MAX_VALUE;
                //从第1层开始扔
                for (int f = 1; f < t1; f++) {
                    //如果鸡蛋没碎,求解方程就是t1-f楼，n1个蛋的情况
                    int timesA = a[t1 - f][n1];
                    //如果鸡蛋碎了，证明还有f-1层楼，n1-1个蛋的情况
                    int timesB = a[f - 1][n1 - 1];
                    //先取最坏情况需要探测的次数，在找到最好的楼层扔法
                    int bad = Math.max(timesA, timesB) + 1;
                    //计算最坏情况的最好解法
                    min = Math.min(min,bad);
                }
                //按楼层不变，蛋数递增的情况一步步填充。
                a[t1][n1] = min;
            }
        }
        for (int i = 1; i < a.length; i++) {
            for (int j = 1; j < a[i].length; j++) {
                System.out.println(i+"层楼"+j+"个蛋的最好扔法需扔："+a[i][j]+"次");
            }
        }

    }
    public static void main(String[] args){
        new Egg().dp(100,2);
    }
}