那个谷歌的网红扔鸡蛋的题，来看看教科书式的回答

 leetcode顶级难题，谷歌面试天天问，来看看吧，带你来一步一步达到最优解。

谷歌不知道问了多少遍，蓝桥杯也出现过，leetcode上是顶级难题，到底是什么题能如此频繁地出现？我们一探究竟吧。

        x星球的居民脾气不太好，但好在他们生气的时候唯一的异常举动是：摔手机。
各大厂商也就纷纷推出各种耐摔型手机。x星球的质监局规定了手机必须经过耐摔测试，并且评定出一个耐摔指数来，之后才允许上市流通。
        x星球有很多高耸入云的高塔，刚好可以用来做耐摔测试。塔的每一层高度都是一样的，与地球上稍有不同的是，他们的第一层不是地面，而是相当于我们的2楼。
        如果手机从第7层扔下去没摔坏，但第8层摔坏了，则手机耐摔指数=7。

特别地，如果手机从第1层扔下去就坏了，则耐摔指数=0。如果到了塔的最高层第n层扔没摔坏，则耐摔指数=n

        为了减少测试次数，从每个厂家抽样3部手机参加测试。
        某次测试的塔高为1000层，如果我们总是采用最佳策略，在最坏的运气下最多需要测试多少次才能确定手机的耐摔指数呢？
        请填写这个最多测试次数。

        注意：需要填写的是一个整数，不要填写任何多余内容

答案19

文章目的

读完题后，我们追求的不是要写出得数，而是用代码实现方法，并思考是否可以优化。

其实本题的方法是非常多种多样的。非常适合锻炼思维。

我们把问题扩展到n个手机来思考。

手机k个，楼n层，最终结果M次。

时空复杂度目录

暴力：                        O(N!)

DP:                            O(N*N*K)  O(N*K)

压空间：                    O(N*N*K)  O(N)

四边形不等式优化     O(N*N)       

换思路：                    O(K*M)

最优：                         O(K*M)    O(N)

文末有测试，大家可以去直观感受一下各方法运行的效率

二分

容易想到二分思路：不断二分范围，取中点，测验是否会摔坏，然后缩小一半范围，继续尝试，很显然，答案为logN（2为底）

但是，二分得出的答案是不对的。注意:我们要保证在都手机摔完之前，能确定耐摔指数到底是多少。

举例：

我们在500楼摔坏了，在250楼摔，又坏了。接下来，我们只能从1楼开始一层一层试

因为如果我们在125层摔坏了，就没有手机可以用，也就是永远都测不出来，而这是不被允许的。其实我们连测第2层都不敢测，因为在第2层摔坏了，我们就无法知道手机在第一层能否被摔坏。所以只有一部手机时，我们只敢从第一层开始摔。

尝试较优的策略

既然二分是不对的，我们继续分析：摔手机的最优策略到底是如何的。

只有一部手机时，我们只敢从第一层开始摔。

有两部手机的时候，我们就敢隔层摔了，因为一部手机坏了，我们还有另一部来继续试。

这时就有点意思了，我们分析情况：

情况1）假设我们第一部手机在i层摔坏了，然后最坏情况还要试多少次？这时我们还剩一部手机，所以只敢一层一层试，最坏情况要试到i-1层，共试了i次。

情况2）假设我们第一部手机在i层试了，但是没摔坏，然后最坏情况还要试多少次？（这时发现算情况2时依旧是相似的问题，确定了可以用递归来解。）

最优解（最小值）是决策后两种情况的最差情况（最大值），我们的本能感觉应该就是让最差情况好一点，让最好情况差一点，这样比较接近正确答案。比如两部手机，一百层，我们可以在50层摔，没坏，这一次就很赚，我们没摔坏手机还把范围缩小了50层。如果坏了，就比较坑了，我们要从1试到50。虽然可能缩小一半，但是最坏情况次数太多，所以肯定要从某个低于五十的层开始尝试。

（以上几行是为了让读者理解决策，下面正文分析）

归纳表达式

假设我们的楼一共n层，我们的i可以取1-n任意值，有很多种可能的决策，我们的最小值设为f（n，k），n代表楼高（范围为1-100或101-200其实都一样），k代表手机数.

我们假设的决策是在第i楼扔

对于情况一，手机少了一部，并且我们确定了范围，一定在第i楼以下，所以手机-1，层数为i-1，这时f（n，k）=f(i-1,k-1).+1

对于情况二，手机没少，并且我们确定了范围，一定在第i楼之上，所以手机数不变，而层数-i层，这时f（n，k）=f(n-i,k).+1

归纳出

f（n，k）=min（  max（f(i-1,k-1) ，f(n-i,k) ） i取1-n任意数    ）+1

简单总结：怎么确定第一个手机在哪扔？每层都试试，哪层的最坏情况（max）最好（min），就去哪层扔。

写出暴力递归

按照分析出来的表达式，我们可以写出暴力递归：

public static int solution1(int nLevel, int kChess) {
if (nLevel == 0) {
return 0;
}//范围缩小至0
if (kChess == 1) {
return nLevel;
}//每层依次试
int min = Integer.MAX_VALUE;//取不影响结果的数
for (int i = 1; i != nLevel + 1; i++) {
//尝试所有决策，取最优
min = Math.min(
min,
Math.max(Process1(i - 1, kChess - 1),Process1(nLevel - i, kChess)));
}
return min + 1;//别忘了加上本次
}

改为动态规划

具体思路如下

https://blog.csdn.net/hebtu666/article/details/79912328

public static int solution2(int nLevel, int kChess) {
if (kChess == 1) {
return nLevel;
}
int[][] dp = new int[nLevel + 1][kChess + 1];
for (int i = 1; i != dp.length; i++) {
dp[i][1] = i;
}
for (int i = 1; i != dp.length; i++) {
for (int j = 2; j != dp[0].length; j++) {
int min = Integer.MAX_VALUE;
for (int k = 1; k != i + 1; k++) {
min = Math.min(min,
Math.max(dp[k - 1][j - 1], dp[i - k][j]));
}
dp[i][j] = min + 1;
}
}
return dp[nLevel][kChess];
}

压缩空间

我们发现，对于状态转移方程，只和上一盘排的dp表和左边的dp表有关，所以我们不需要把值全部记录，用两个长度为n的数组不断更新即可（具体对dp压缩空间的思路，也是很重要的，我在其它文章中有提过，在这里就不写了）

public static int solution3(int nLevel, int kChess) {
if (kChess == 1) {
return nLevel;
}
int[] preArr = new int[nLevel + 1];
int[] curArr = new int[nLevel + 1];
for (int i = 1; i != curArr.length; i++) {
curArr[i] = i;
}//初始化
for (int i = 1; i != kChess; i++) {
//先交换
int[] tmp = preArr;
preArr = curArr;
curArr = tmp;
//然后打新的一行
for (int j = 1; j != curArr.length; j++) {
int min = Integer.MAX_VALUE;
for (int k = 1; k != j + 1; k++) {
min = Math.min(min, Math.max(preArr[k - 1], curArr[j - k]));
}
curArr[j] = min + 1;
}
}
return curArr[curArr.length - 1];
}

四边形不等式优化

四边形不等式是一种比较常见的优化动态规划的方法

定义：如果对于任意的a1≤a2

对s[i,j-1]≤s[i,j]≤s[i+1,j]的证明：

设mk[i,j]=m[i,k]+m[k,j]，s[i,j]=d

对于任意k

(mk[i+1,j]-md[i+1,j])-(mk[i,j]-md[i,j])

=(mk[i+1,j]+md[i,j])-(md[i+1,j]+mk[i,j])

=(m[i+1,k]+m[k,j]+m[i,d]+m[d,j])-(m[i+1,d]+m[d,j]+m[i,k]+m[k,j])

=(m[i+1,k]+m[i,d])-(m[i+1,d]+m[i,k])

∵m满足四边形不等式，∴对于i

∴(mk[i+1,j]-md[i+1,j])≥(mk[i,j]-md[i,j])≥0

∴s[i,j]≤s[i+1,j]，同理可证s[i,j-1]≤s[i,j]

证毕

通俗来说，

优化策略1）我们在求k+1手机n层楼时，最后发现，第一个手机在m层扔导致了最优解的产生。那我们在求k个手机n层楼时，第一个手机的策略就不用尝试m层以上的楼了。

优化策略2）我们在求k个手机n层楼时，最后发现，第一个手机在m层扔导致了最优解的产生。那我们在求k个手机n+1层楼时，就不用尝试m层以下的楼了。

public static int solution4(int nLevel, int kChess) {
if (kChess == 1) {
return nLevel;
}
int[][] dp = new int[nLevel + 1][kChess + 1];
for (int i = 1; i != dp.length; i++) {
dp[i][1] = i;
}
int[] cands = new int[kChess + 1];
for (int i = 1; i != dp[0].length; i++) {
dp[1][i] = 1;
cands[i] = 1;
}
for (int i = 2; i for (int j = kChess; j > 1; j--) {
int min = Integer.MAX_VALUE;
int minEnum = cands[j];
int maxEnum = j == kChess ? i / 2 + 1 : cands[j + 1];
//优化策略
for (int k = minEnum; k int cur = Math.max(dp[k - 1][j - 1], dp[i - k][j]);
if (cur <= min) {
min = cur;
cands[j] = k;//最优解记录层数
}
}
dp[i][j] = min + 1;
}
}
return dp[nLevel][kChess];
}

注：对于四边形不等式的题目，比赛时不需要严格证明

通常的做法是打表出来之后找规律，然后大胆猜测，显然可得。（手动滑稽）

换一种思路

有时，最优解并不是优化来的。

当你对着某个题冥思苦想了好久，无论如何也不知道怎么把时间优化到合理范围，可能这个题的最优解就不是这种思路，这时，试着换一种思路思考，可能会有奇效。

（比如训练时一道贪心我死活往dp想，肝了两个小时以后，不主攻这个方向的队友三分钟就有贪心思路了，泪目，不要把简单问题复杂化）

我们换一种思路想问题：

原问题：n层楼，k个手机，最多测试次数

反过来看问题：k个手机，扔m次，最多能确定多少层楼？

我们定义dp[i][j]：i个手机扔j次能确定的楼数。

分析情况：依旧是看第一部手机在哪层扔的决策，同样，我们的决策首先要保证能确定从1层某一段，而不能出现次数用完了还没确定好的情况。以这个为前提，保证了每次扔的楼层都是最优的，就能求出结果。

依旧是取最坏情况：min（情况1，情况2）

情况1）第一个手机碎了，我们就需要用剩下的i-1个手机和j-1次测试次数往下去测，dp[i-1][j-1]。那我们能确定的层数是无限的，因为本层以上的无限层楼都不会被摔坏。dp[i-1][j-1]+无穷=无穷

情况2）第一个手机没碎，那我们就看i个手机扔j-1次能确定的楼数（向上试）+当前楼高h

归纳表达式，要取最差情况，所以就是只有情况2：dp[i][j]=dp[i-1][j-1]+h

那这个h到底是什么呢？取决于我敢从哪层扔。因为次数减了一次，我们还是要考虑i个球和j-1次的最坏情况能确定多少层，我才敢在层数+1的地方扔。（这是重点）

也就是dp[i][j-1]的向上一层：h=dp[i][j-1]+1

总：min（情况1，情况2）=min（无穷，dp[i-1][j-1]+dp[i][j-1]+1）=dp[i-1][j-1]+dp[i][j-1]+1

这是解决k个手机，扔m次，最多能确定多少层楼？

原问题是n层楼，k个手机，最多测试次数。

所以我们在求的过程中，何时能确定的层数大于n，输出扔的次数即可

最优解

我们知道完全用二分扔需要logN+1次，这也绝对是手机足够情况下的最优解，我们做的这么多努力都是因为手机不够摔啊。。。。所以当我们的手机足够用二分来摔时，直接求出logN+1即可。

当然，我们求dp需要左边的值和左上的值：

依旧可以压缩空间，从左往右更新，previous记录左上的值。

求自己时也要注意记录，否则更新过后，后面的要用没更新过的值（左上方）就找不到了。

记录之后，求出当前数值，把记录的temp值给了previous即可。

public static int solution5(int nLevel, int kChess) {
int bsTimes = log2N(nLevel) + 1;
if (kChess >= bsTimes) {
return bsTimes;
}
int[] dp = new int[kChess];
int res = 0;
while (true) {
res++;//压缩空间记得记录次数
int previous = 0;
for (int i = 0; i int tmp = dp[i];
dp[i] = dp[i] + previous + 1;
previous = tmp;
if (dp[i] >= nLevel) {
return res;
}
}
}
}
public static int log2N(int n) {
int res = -1;
while (n != 0) {
res++;
n >>>= 1;
}
return res;
}

本题只是填空题，第一种方法就完全能算出来，就是为了追求最优解，追求思维的锻炼。写下了本文。

暴力：                        O(N!)

DP:                            O(N*N*K)  O(N*K)

压空间：                    O(N*N*K)  O(N)

四边形不等式优化     O(N*N)       

最优：                         O(K*M)    O(N)

long start = System.currentTimeMillis();
solution1(30, 2);
long end = System.currentTimeMillis();
System.out.println("cost time: " + (end - start) + " ms");
start = System.currentTimeMillis();
solution2(30, 2);
end = System.currentTimeMillis();
System.out.println("cost time: " + (end - start) + " ms");
start = System.currentTimeMillis();
solution3(30, 2);
end = System.currentTimeMillis();
System.out.println("cost time: " + (end - start) + " ms");
start = System.currentTimeMillis();
solution4(30, 2);
end = System.currentTimeMillis();
System.out.println("cost time: " + (end - start) + " ms");
start = System.currentTimeMillis();
solution5(30, 2);
end = System.currentTimeMillis();
System.out.println("cost time: " + (end - start) + " ms");
/*
结果：
cost time: 7043 ms
cost time: 0 ms
cost time: 0 ms
cost time: 0 ms
cost time: 0 ms
*/

暴力时间实在是太久了，只测一个30，2

后四种方法测的大一些（差点把电脑测炸了，cpu100内存100）：

solution(100000, 10):

solution2 cost time: 202525 ms
solution3 cost time: 38131 ms
solution4 cost time: 11295 ms
solution5 cost time: 0 ms

感受最优解的强大：

solution5(1000 000 000,100):0 ms

solution5(1000 000 000,10):0 ms

最优解永远都是0 ms，我也是服了。。

对比方法，在时间复杂度相同的条件下，空间复杂度一样会影响时间，因为空间太大的话，申请空间是相当浪费时间的。并且空间太大电脑会炸，所以不要认为空间不重要。