N个鸡蛋从M楼层摔（2个鸡蛋从100层摔）

阅读数：4866

一、题目：
　　有一栋楼共100层，一个鸡蛋从第N层及以上的楼层落下来会摔破，在第N层以下的楼层落下不会摔破。给你2个鸡蛋，设计方案找出N，并且保证在最坏情况下，最小化鸡蛋下落的次数。

二、思路：
　　先假设，最小的次数为x次。
　　首先在x层摔，那么会出现两个结果：
　　1、碎了，为了找出那一层碎了，第二个鸡蛋必须从1~x-1进行遍历的摔
　　2、没碎，那么第二次就在x+(x-1)楼层摔。

为什么是x+x-1楼层呢？
首先我们已经假设了通过x步我们就能得到答案，现在我们在x层已经用了一次了，那么就只剩下x-1步了。所以我们选择x+(x-1)层，如果碎了，我们就能通过x-2步，遍历x+1~x+(x-1)-1的所有楼层。

　　3、如果在x+(x-1)楼碎了，那么同1，遍历x+1~x+(x-1)-1
　　4、没碎，那么同2，就在x+(x-1)+(x-2)层摔
　　…
　　最后我们将会得出这样一个楼层公式x+(x-1)+(x-2)+…+1 = x(x+1)/2。
　　这个公式有什么意义呢？
　　有， x(x+1)/2 >= 100，这样才能顺利的解除x。
　　有人说，x(x+1)/2 = 99就可以，如果鸡蛋在99层都没碎，那么必定是100层。我想说谁告诉你记得一定会碎！
　　那么我们就顺利的解除 x=14。

三、扩展
　　此题还有一个扩展，就是为N个鸡蛋从M层摔找出最小值。
　　那就不是很好手解了，所以写了代码，使用动态规划原理。动态规划式子如下：

f[n][m] = 1+max(f[n-1][k-1],f[n][m-k]) k属于[1,m-1]
解释下原理：
1、当手里有n个的时候，鸡蛋从k层往下摔，如果破了，那么手里只有n-1鸡蛋了，那么就需要测试f[n-1][k-1]楼层。或者更通俗好理解点的，我们运用2个鸡蛋100楼层的题目举例子。以上式子变为：f[2][m] = 1+max(f[1][k-1],f[2][m-k])
　　那么当手里有2个鸡蛋的时候，在k层摔，碎了。那么现在手里也就只有一个鸡蛋了，此时我们必须遍历1~k-1找出第一次碎的楼层。所以为1+f[1][m-k]，前面的1代表在k层的操作。
2、没破，那么手里还有n个鸡蛋，那么需要测试k+1~m这些楼层。

此时我想问下，当手里有2个鸡蛋测试1~m-k层和手里有2个鸡蛋测试k+1~m有什么区别？
有人说有，因为楼层越高越容易碎，那其实是你个人的想法罢了。其实并没有区别，所以第一个公式可以写为f[n][m-k]。

最后附上代码，为了理解方便，而不必从数组从0开始而困扰，这里就空间多开了点，所以如果拿去用的话，可以优化下：

public class Eggs{
    public int countMinSetp(int egg,int num){
        if(egg < 1 || num < 1) return 0;
        int[][] f = new int[egg+1][num+1];//代表egg个鸡蛋，从num楼层冷下来所需的最小的次数
        for(int i=1;i<=egg; i++){
            for(int j=1; j<=num; j++)
                f[i][j] = j;//初始化，最坏的步数
        }

        for(int n=2; n<=egg; n++){
            for(int m=1; m<=num; m++){
                for(int k=1; k<m; k++){
                    //这里的DP的递推公式为f[n][m] = 1+max(f[n-1][k-1],f[n][m-k]) k属于[1,m-1]
                    //从1-m层中随机抽出来一层k
                    //如果第一个鸡蛋在k层碎了，那么我们将测试1~k-1层，就可以找出来，也即1+f[1][k-1]
                    //如果第一个鸡蛋在k层没有碎，那么我们将测试k+1~m也即m-k层，
                    //      这里也是重点！！！！ 
                    //      现在我们手里有2个鸡蛋，要测试m-k层，那么我想问，此时和你手里有2个鸡蛋要测试1~m-k层有什么区别？
                    //      没有区别！是的在已知k层不碎的情况下，测试k+1~m层的方法和测试1~m-k没区别，所以可以写成 1+f[n][m-k] 其中1表示为 在k层的那一次测试
                    f[n][m] = Math.min(f[n][m],1+Math.max(f[n-1][k-1],f[n][m-k]));
                }
            }
        }
        return f[egg][num];
    }
    public static void main(String[] args) {
        Eggs e = new Eggs();
        System.out.println(e.countMinSetp(2,100));
    }
}

参考文章：
100层楼2个鸡蛋，如何得知鸡蛋能承受几层的撞击
 两个鸡蛋100层楼(DP)

为什么是x+x-1楼层呢？
首先我们已经假设了通过x步我们就能得到答案，现在我们在x层已经用了一次了，那么就只剩下x-1步了。所以我们选择x+(x-1)层，如果碎了，我们就能通过x-2步，遍历x+1~x+(x-1)-1的所有楼层。

f[n][m] = 1+max(f[n-1][k-1],f[n][m-k]) k属于[1,m-1]
解释下原理：
1、当手里有n个的时候，鸡蛋从k层往下摔，如果破了，那么手里只有n-1鸡蛋了，那么就需要测试f[n-1][k-1]楼层。或者更通俗好理解点的，我们运用2个鸡蛋100楼层的题目举例子。以上式子变为：f[2][m] = 1+max(f[1][k-1],f[2][m-k])
　　那么当手里有2个鸡蛋的时候，在k层摔，碎了。那么现在手里也就只有一个鸡蛋了，此时我们必须遍历1~k-1找出第一次碎的楼层。所以为1+f[1][m-k]，前面的1代表在k层的操作。
2、没破，那么手里还有n个鸡蛋，那么需要测试k+1~m这些楼层。

此时我想问下，当手里有2个鸡蛋测试1~m-k层和手里有2个鸡蛋测试k+1~m有什么区别？
有人说有，因为楼层越高越容易碎，那其实是你个人的想法罢了。其实并没有区别，所以第一个公式可以写为f[n][m-k]。

最后附上代码，为了理解方便，而不必从数组从0开始而困扰，这里就空间多开了点，所以如果拿去用的话，可以优化下：

public class Eggs{
    public int countMinSetp(int egg,int num){
        if(egg < 1 || num < 1) return 0;
        int[][] f = new int[egg+1][num+1];//代表egg个鸡蛋，从num楼层冷下来所需的最小的次数
        for(int i=1;i<=egg; i++){
            for(int j=1; j<=num; j++)
                f[i][j] = j;//初始化，最坏的步数
        }

        for(int n=2; n<=egg; n++){
            for(int m=1; m<=num; m++){
                for(int k=1; k<m; k++){
                    //这里的DP的递推公式为f[n][m] = 1+max(f[n-1][k-1],f[n][m-k]) k属于[1,m-1]
                    //从1-m层中随机抽出来一层k
                    //如果第一个鸡蛋在k层碎了，那么我们将测试1~k-1层，就可以找出来，也即1+f[1][k-1]
                    //如果第一个鸡蛋在k层没有碎，那么我们将测试k+1~m也即m-k层，
                    //      这里也是重点！！！！ 
                    //      现在我们手里有2个鸡蛋，要测试m-k层，那么我想问，此时和你手里有2个鸡蛋要测试1~m-k层有什么区别？
                    //      没有区别！是的在已知k层不碎的情况下，测试k+1~m层的方法和测试1~m-k没区别，所以可以写成 1+f[n][m-k] 其中1表示为 在k层的那一次测试
                    f[n][m] = Math.min(f[n][m],1+Math.max(f[n-1][k-1],f[n][m-k]));
                }
            }
        }
        return f[egg][num];
    }
    public static void main(String[] args) {
        Eggs e = new Eggs();
        System.out.println(e.countMinSetp(2,100));
    }
}

参考文章：
100层楼2个鸡蛋，如何得知鸡蛋能承受几层的撞击
 两个鸡蛋100层楼(DP)

面试题-扔鸡蛋，N个鸡蛋从M楼层摔（2个鸡蛋从100层摔） N个鸡蛋从M楼层摔（2个鸡蛋从100层摔）

N个鸡蛋从M楼层摔（2个鸡蛋从100层摔）

猜你喜欢