您的位置：首页 > 运维架构

扔鸡蛋问题(Egg Dropping Puzzle)

2015-10-11 00:32 295 查看
文章转自：Acm之家'target='_blank'>http://www.acmerblog.com/egg-dropping-puzzle-5591.html
据说这是一道google的面试题.看似是一个智力题，实际是编程题。

两个软硬程度一样但未知的鸡蛋，它们有可能都在一楼就摔碎，也可能从一百层楼摔下来没事。现有座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个鸡蛋。

最优子结构可以表示为：

1
k
==>楼层数
2
n
==>鸡蛋数
3
eggDrop(n,
k)==>最少需要的测试次数(考虑所有情况)
4
eggDrop(n,
k)=1+min{max(eggDrop(n-1,x-1),eggDrop(n,k-x)):
5
x
属于{1,2,...,k}}
下面用递归的方法解决这个问题：

01
#
include<stdio.h>
02
#
include<limits.h>
03
04
int
max(
int
a,
int
b)
{
return
(a
>b)?a:b;}
05
06
int
eggDrop(
int
n,
int
k)
07
{
08
//
基本情况
09
if
(k
==1||k==0)
10
return
k;
11
12
//如果只有一个鸡蛋，最坏的情况下需要k测试
13
if
(n
==1)
14
return
k;
15
16
int
min
=INT_MAX,x,res;
17
18
//
考虑从第1层到底k层扔下鸡蛋的所有情况的最小结果
19
for
(x
=1;x<=k;x++)
20
{
21
res
=max(eggDrop(n-1,x-1),eggDrop(n,k-x));
22
if
(res
<min)
23
min
=res;
24
}
25
return
min
+1;
26
}
27
28
/*
测试*/
29
int
main()
30
{
31
int
n
=2,k=10;
32
printf
(
"\nMinimum
numberoftrialsinworstcasewith%deggsand"
33
"%d
floorsis%d\n"
,
n,k,eggDrop(n,k));
34
return
0;
35
}
上面的程序问题是复杂度太大O(2^k)。如果k=36的话，基本是跑不出结果。

重叠子问题

因为上面的程序重复计算了很多子问题。以E(2,4)为例：

01
E(2,4)
02
|
03
-------------------------------------
04
|
|||
05
|
|||
06
x=1/\
x=2/\x=3/\x=4/\
07
/
\/\........
08
/
\/\
09
E(1,0)
E(2,3)E(1,1)E(2,2)
10
/\
/\.../\
11
x=1/
\.....
12
/
\
13
E(1,0)
E(2,2)
14
/
\
15
......
16
对于2个鸡蛋，4层楼
部分递归
因此完全可以用动态规划解决。

01
#
include<stdio.h>
02
#
include<limits.h>
03
int
max(
int
a,
int
b)
{
return
(a
>b)?a:b;}
04
int
eggDrop(
int
n,
int
k)
05
{
06
/*
eggFloor[i][j]表示对于i个鸡蛋j层楼，需要的最少测试次数*/
07
int
eggFloor[n+1][k+1];
08
int
res;
09
int
i,
j,x;
10
//
初始化
11
for
(i
=1;i<=n;i++)
12
{
13
eggFloor[i][1]
=1;
14
eggFloor[i][0]
=0;
15
}
16
17
//只有一个鸡蛋，没得优化，需要j次
18
for
(j
=1;j<=k;j++)
19
eggFloor[1][j]
=j;
20
21
//
最优子结构的递推
22
for
(i
=2;i<=n;i++)
23
{
24
for
(j
=2;j<=k;j++)
25
{
26
eggFloor[i][j]
=INT_MAX;
27
for
(x
=1;x<=j;x++)
28
{
29
res
=1+max(eggFloor[i-1][x-1],eggFloor[i][j-x]);
30
if
(res
<eggFloor[i][j])
31
eggFloor[i][j]
=res;
32
}
33
}
34
}
35
return
eggFloor
[k];
36
}
37
38
/*
测试*/
39
int
main()
40
{
41
int
n
=2,k=36;
42
printf
(
"\nMinimum
numberoftrialsinworstcasewith%deggsand"
43
"%d
floorsis%d\n"
,
n,k,eggDrop(n,k));
44
return
0;
45
}
参考：http://www.geeksforgeeks.org/dynamic-programming-set-11-egg-dropping-puzzle/
                                            

                                        

                        
                        内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 点击这里给我发消息 
                    

                    

                    

                        

                         标签： 
                                                

                        

                    


                

            


            

                
相关文章推荐

                

                
            

        

        

            

            
            

                

                    
新的分享

                    

                        
                    

                

            


            

                

                    
章节导航