对于高楼扔鸡蛋问题，本文尝试反其道而行之：首先描述一个普适的高楼扔鸡蛋问题，然后利用动态规划法解决扔鸡蛋次数的问题，最后由获取次数的答案反推出扔鸡蛋的方法。
这种由次数答案反推出方法的演绎方式令人有点震惊，似乎不同于常见的人类思考方式，有点像“先假设再证明”一样。感觉这个题目还有继续深挖的可能，比如找出数学上的证明或直接的扔鸡蛋方法。

问题描述

有M层楼和N个鸡蛋，要找到扔下鸡蛋而鸡蛋不碎的最低楼层（也称为“临界楼层”），最少尝试多少次就一定能找到这个“最低楼层”？

这个题意其实并不那么直观，有以下的几个注意点：
1. 因为鸡蛋数量有限，所以不可能使用二分法解题。比如，有100层楼和1个鸡蛋，那么只好从第1层开始，逐层往上试。所以，在最坏情况下，要试验100次，即答案为100.
2. 不能说“最少只需要尝试2次就能找出最低摔不碎的楼层”，因为“2次就找到”的情况并不能保证“一定”找到，只是碰巧找到而已。
3. 具体使用什么方法扔鸡蛋，现在可以不知道！但又要知道的一点是，从不同层开始第一次扔鸡蛋所得到的最坏情况下的最少尝试次数是不同的。
这一点可能比较难以理解。这等于是：我们首先假设必然存在一种方法，该方法一定能够找出临界楼层，但是该方法以不同楼层为第一次扔鸡蛋的楼层时，最坏情况下所需的扔鸡蛋次数是不同的。比如，100层楼+2个鸡蛋，我以第50层为初始楼层，在其最坏情况下获得临界楼层，所需扔鸡蛋次数为A次；而以第14层为初始楼层，在其最坏情况下获得临界楼层，所需扔鸡蛋次数为B次。 A不等于B；且50层初始楼层和14层初始楼层其各自的最坏情况也是不同的。最终答案是以每一层为初始楼层时所有答案中的最小值。

动态规划法

本题采用动态规划法解题。简单来说，动态规划解题分为2步：
1. 定义状态转移方程
2. 利用状态转移方程，自底向上求解

具体运用

首先，假设楼层数为M，鸡蛋数为N，函数为 F(M, N), 函数的返回值为答案，即“以各楼层为初始楼层时，在其各自最坏情况下的尝试次数的最小值”。

假设初始楼层为第X层，在该层摔鸡蛋，
1> 若没有碎，则继续尝试更高的 M-X 层，因此 F(M, N) = 1 + F(M-X, N)
2> 若破碎了，则继续尝试更低的 X-1 层，因此 F(M, N) = 1 + F(X-1, N-1)

所以，以第X层为初始楼层的最坏情况就是以上二者的最大值，即：

1 + Max(F(M-X, N), F(X-1, N-1))  （当X为初始楼层）

因为每层楼都可能作为初始楼层来扔鸡蛋，所以，实际上存在某一楼层为初始楼层，其尝试次数可以达到最少。也就是说：

F(M, N) = Min(1 + Max(F(M-X, N), F(X-1, N-1)))   # X 属于 [1, M]

这样，就可以写程序了。当找到尝试次数的最小值的时候，也就找到了初始楼层。这就为我们反推出扔鸡蛋的方法也提供了方法。程序如下(对于100层楼+2个鸡蛋，当然，楼的层数和鸡蛋的个数是可以设置的)：

cache = dict()
floors_result = dict()  # each floor's max trying numberdef f(m, n, first_level=False):if m == 0:return 0if m == 1:return 1if n == 1:return mm_cache = cache.get(m)if m_cache and m_cache.get(n):return cache[m][n]result_list = list()for i in range(m):i += 1result = max(f(m-i, n), f(i-1, n-1)) + 1result_list.append(result)if first_level:floors_result[i] = resultresult = min(result_list)if not cache.get(m):cache[m] = dict()cache[m][n] = resultreturn resultdef main():m = 100n = 2result = f(m, n, True)for flr, res in floors_result.items():if res == result:first_floor = flrbreakprint("F(%s, %s) = %s, first floor is %s" % (m, n, result, first_floor))print("{}".format(floors_result))main()

程序的打印结果如下：

$ python 1.py
F(100, 2) = 14, first floor is 9
{1: 15, 2: 15, 3: 15, 4: 15, 5: 15, 6: 15, 7: 15, 8: 15, 9: 14, 10: 14, 11: 14, 12: 14, 13: 14, 14: 14, 15: 15, 16: 16, 17: 17, 18: 18, 19: 19, 20: 20, 21: 21, 22: 22, 23: 23, 24: 24, 25: 25, 26: 26, 27: 27, 28: 28, 29: 29, 30: 30, 31: 31, 32: 32, 33: 33, 34: 34, 35: 35, 36: 36, 37: 37, 38: 38, 39: 39, 40: 40, 41: 41, 42: 42, 43: 43, 44: 44, 45: 45, 46: 46, 47: 47, 48: 48, 49: 49, 50: 50, 51: 51, 52: 52, 53: 53, 54: 54, 55: 55, 56: 56, 57: 57, 58: 58, 59: 59, 60: 60, 61: 61, 62: 62, 63: 63, 64: 64, 65: 65, 66: 66, 67: 67, 68: 68, 69: 69, 70: 70, 71: 71, 72: 72, 73: 73, 74: 74, 75: 75, 76: 76, 77: 77, 78: 78, 79: 79, 80: 80, 81: 81, 82: 82, 83: 83, 84: 84, 85: 85, 86: 86, 87: 87, 88: 88, 89: 89, 90: 90, 91: 91, 92: 92, 93: 93, 94: 94, 95: 95, 96: 96, 97: 97, 98: 98, 99: 99, 100: 100}

由上可知，对于100层楼+2个鸡蛋，首次可以在第9层至第14层中的任何一层扔都可以！最坏情况下需要扔14次鸡蛋才能确定临界楼层。
假设第一次是在第14层扔的，没有碎，那么第二次扔鸡蛋应该在哪层呢？
这个时候就很简单了:
如果在第14层扔鸡蛋破碎了，那么后面就从第1层开始逐层向上尝试，最多尝试13次，即 F(13, 1) = 13
如果在第14层扔鸡蛋没有碎，那么相当于要求解 F(100-14, 2) = F(86,2) 由程序中的cache可知，F(86, 2) = 13, 所以第二次尝试的楼层应该为 14+13=27 层。然后，27层又分碎了和没碎两种情况，可按照如上的方法继续推理，直至找到临界楼层。

于是，以上就确定了扔鸡蛋的方法了。

那么，对于100层楼+2个鸡蛋，可以使用以下程序得到“一直摔不碎第一个鸡蛋的情况下的所有尝试楼层”，故以下程序不适用大于2个鸡蛋的情况，但对于大于2个鸡蛋的情况，通过上一段描述的方法，也可以得到答案。

cache = dict()
floors_result = dict()  # each floor's max trying numberdef f(m, n, first_level=False):if m == 0:return 0if m == 1:return 1if n == 1:return mm_cache = cache.get(m)if m_cache and m_cache.get(n):return cache[m][n]result_list = list()for i in range(m):i += 1result = max(f(m-i, n), f(i-1, n-1)) + 1result_list.append(result)if first_level:floors_result[i] = resultresult = min(result_list)if not cache.get(m):cache[m] = dict()cache[m][n] = resultreturn resultdef main():m = 100n = 2floor_list = list()    result = f(m, n, True)floor = -1for flr, res in floors_result.items():if res == result:floor = flrbreakfloor_list.append(floor)while floor <= m - 1:result = f(m-floor, n)floor += resultfloor_list.append(floor)print(floor_list)main()

执行结果是：

[9, 22, 34, 45, 55, 64, 72, 79, 85, 90, 94, 97, 99, 100]

我们平常搜索“高楼扔鸡蛋”，看到解答一般都是100层+2个鸡蛋对应的都是从14层开始扔，最多14次找到临界楼层。但是由以上的分析可知，其实从9-14层的任何一层，都可以是最多14次找到临界楼层。

(完）

高楼扔鸡蛋问题 - 动态规划+反推演绎相关推荐

每日一道算法题：高楼扔鸡蛋问题(动态规划问题)
题目是这样:你面前有一栋从 1 到N共N层的楼,然后给你K个鸡蛋(K至少为 1).现在确定这栋楼存在楼层0 <= F <= N,在这层楼将鸡蛋扔下去,鸡蛋恰好没摔碎(高于F的楼层都会碎,低 ...
java动态规划鸡蛋问题_动态规划系列/高楼扔鸡蛋问题.md · lipengfei/fucking-algorithm - Gitee.com...
# 经典动态规划问题:高楼扔鸡蛋今天要聊一个很经典的算法问题,若干层楼,若干个鸡蛋,让你算出最少的尝试次数,找到鸡蛋恰好摔不碎的那层楼.国内大厂以及谷歌脸书面试都经常考察这道题,只不过他们觉得扔鸡蛋 ...
高楼扔鸡蛋——动态规划问题
今天算法课大伙做了一份课堂测验,是有关一维以及二维动态规划问题的,其中最后一天压轴的就是这道高楼扔鸡蛋问题. 在我得意洋洋以为能早早做完这份测验然后交卷的时候,我在这道题上摁是扣了半小时头皮,也没写出 ...
高楼扔鸡蛋问题-经典动态规划
文章目录 1. 高楼扔鸡蛋 2. 猜数字大小 1. 高楼扔鸡蛋给你 k 枚相同的鸡蛋,并可以使用一栋从第 1 层到第 n 层共有 n 层楼的建筑. 已知存在楼层 f ,满足 0 <= f &l ...
【LeetCode系列】高楼扔鸡蛋
高楼扔鸡蛋题目描述:面前有一栋楼从1到N共N层的楼,然后给你K个鸡蛋(K至少为1).现在确定这栋楼存在楼层0<=F<=N,在这层楼将鸡蛋扔下去,鸡蛋恰好没摔碎(高于F的楼层都会碎,低于F ...
Algorithm——高楼扔鸡蛋
问题描述高楼扔鸡蛋问题是一道经典的动态规划问题,题目如下: 给你 k 枚相同的鸡蛋,并可以使用一栋从第 1 层到第 n 层共有 n 层楼的建筑.已知存在楼层 f ,满足 0 <= f < ...
经典谷歌面试题：高楼扔鸡蛋
经典谷歌面试题:高楼扔鸡蛋存在某T层高楼,在该高楼中存在这样的一层,在该层之下的所有楼层扔鸡蛋,鸡蛋摔到地上都不会碎,还可以继续扔:在该层及该层之上的所有楼层,扔下鸡蛋都会摔碎. 目前手里有两个鸡蛋 ...
算法学习笔记——动态规划：高楼扔鸡蛋
LeetCode 887. 鸡蛋掉落建筑有n层(取值1,2,...n),存在一个楼层F(0<=F<=n,注意F取值比n多一个),从高于F的楼层扔鸡蛋,鸡蛋会碎:否则鸡蛋不会碎给你k枚相 ...
经典动态规划：高楼扔鸡蛋
点击蓝色"五分钟学算法"关注我哟加个"星标",天天中午 12:15,一起学算法作者 | labuladong 来源 | labuladong 今天要聊一个很 ...

高楼扔鸡蛋问题 - 动态规划+反推演绎

问题描述

动态规划法

具体运用

高楼扔鸡蛋问题 - 动态规划+反推演绎相关推荐

最新文章

热门文章