The Two Egg Problem
曾经是Google的一道经典题。
题意:有一个百层高楼,鸡蛋在(L)层及以下扔都不碎,在(L)层以上都会碎。现在某人有(k)个鸡蛋,问在最坏情况下,至少扔多少次(用(m)表示)可以确定(L)的值。
分析:先来考虑(k=1)的情况。只有1个鸡蛋,为了得到一个确定的(L),只能从第一层开始,逐渐尝试增加楼层高度,因此(m=100)时,无论(L)的值是多少,都可以被确定。
再来考虑(k=infty)的情况。这种情况就变为了binary search的问题,先拿一个在50层扔,如果碎,则在25层扔;如果不碎,则在75层扔...即(m=7)。
最后来考虑(k=2)的情况。因为(k=1)只能一层一层试,所以第一个鸡蛋应该尽可能缩小搜索空间,但是如果第一个鸡蛋的楼层间隔太小(比如在2层、4层...),无疑会增加(m)。不妨取第一个鸡蛋在10层、20层...,共10次;假如第一个在10层没碎,在20碎了,那么第二个鸡蛋可以尝试11、12...19,共9次;故(m=19)。
上面方案的问题在于:如果临界楼层比较高,那么第二个鸡蛋的次数是确定的,但第一个就需要多试几次,总次数就会增加。
那么如何使得不论临界楼层在哪,(m)的值都不会波动呢?
很简单,只要第一个多扔一次,确定的范围(第二个要试的次数)减小,总次数就会均衡。
对于第一个鸡蛋,第一次在(a)层扔,如果不碎,第二次向上增加(a-1)层...直到最后只向上增加(1)层:(a+(a-1)+...+1geq100),故(ageq13.7)。
鸡蛋一:在14层、27层、39层、50层、60层、69层、77层、84层、90层、95层、99层、100层扔,共12次;
鸡蛋二:如果蛋一在14层碎了,蛋二要扔13次,共14次;如果蛋一在27层碎了,蛋二要扔12次,共14次...故(m=14)。
Super Egg Problem
对于(k=2),我们有了一个比较好的解决方案。那么现在有(k)个鸡蛋,楼高(n)层,问题(记作(m(k,n)))又该如何解决?
(k=1)和(n=1)的情况比较简单:
nk | 1 | 2 | 3 | 4 | ... |
---|---|---|---|---|---|
1 | 1 | 1 | 1 | 1 | |
2 | 2 | ||||
3 | 3 | ||||
... |
那么如果我们递归地思考:任选一层(h)扔第一个鸡蛋,无非有碎和不碎2种情况:
碎:临界楼层在1~h之间,问题规模缩小为(m(k-1,h-1));
不碎:临界楼层在h~n之间,问题规模缩小为(m(k,n-h))。
所以:(m_h(k,n)=1+max{ m(k-1,h-1),m(k,n-h)})。
对于(h),可以采用枚举的方法,计算(m_h(k,n)),在其中选出一个最小的值,故问题得到解决:
Base Case就是(k=1)和(n=1)。
时间复杂度(O(KN^2)),空间复杂度(O(KN))。
记忆化递归:
class Solution {
public:
int superEggDrop(int K, int N) {
vector<vector<int>> memo(K + 1, vector<int>(N + 1, 0));
return helper(K, N, memo);
}
private:
int helper(int K, int N, vector<vector<int>>& memo) {
if(K == 1) {
return N;
}
if(N <= 1) {
return N;
}
if(memo[K][N]) {
return memo[K][N];
}
int ans = INT_MAX;
for(int i = 1;i <= N;++i) {
ans = min(ans, 1 + max(superEggDrop(K - 1, i - 1), superEggDrop(K, N - i)));
}
memo[K][N] = ans;
return ans;
}
};
上述最直观的解法复杂度太高,无法通过Leetcode的数据。如何优化呢?
(m(K,N))表示该问题的解,如果鸡蛋数(K)固定,随着楼层数(N)增加,问题的解一定是增加的。
我们又把问题分解为了2个子问题(m(k-1,h-1))和(m(k,n-h)),(m(k-1,h-1))随(h)单调递增,(m(k,n-h))单调递减(图源):
此时(min(max(...)))就是求中间的折点,可以使用Binary Search,时间复杂度降为(O(KNlgN)):
class Solution {
public:
int superEggDrop(int K, int N) {
vector<vector<int>> memo(K + 1, vector<int>(N + 1, 0));
return helper(K, N, memo);
}
private:
int helper(int K, int N, vector<vector<int>>& memo) {
if(K == 1) {
return N;
}
if(N <= 1) {
return N;
}
if(memo[K][N]) {
return memo[K][N];
}
int ans = INT_MAX;
int l = 1, r = N + 1;
while(l < r) {
int m = l + (r - l) / 2;
int broken = helper(K - 1, m - 1, memo), noBroken = helper(K, N - m, memo);
if(broken > noBroken) {
r = m;
ans = min(ans, 1 + broken);
}
else {
l = m + 1;
ans = min(ans, 1 + noBroken);
}
}
memo[K][N] = ans;
return ans;
}
};
当然,此题还有(O(KN))的做法,甚至还有一种数学做法可以达到(O(KlgN))的时间复杂度和(O(1))的空间复杂度,由于本人水平实在有限,就不再探索。