You are given K eggs, and you have access to a building with N floors from 1 to N.
Each egg is identical in function, and if an egg breaks, you cannot drop it again.
You know that there exists a floor F with 0 <= F <= N such that any egg dropped at a floor higher than F will break, and any egg dropped at or below floor F will not break.
Each move, you may take an egg (if you have an unbroken one) and drop it from any floor X (with 1 <= X <= N).
Your goal is to know with certainty what the value of F is.
What is the minimum number of moves that you need to know with certainty what F is, regardless of the initial value of F?
Example 1:
Input: K = 1, N = 2 Output: 2 Explanation: Drop the egg from floor 1. If it breaks, we know with certainty that F = 0. Otherwise, drop the egg from floor 2. If it breaks, we know with certainty that F = 1. If it didn't break, then we know with certainty F = 2. Hence, we needed 2 moves in the worst case to know what F is with certainty.
Example 2:
Input: K = 2, N = 6 Output: 3
Example 3:
Input: K = 3, N = 14 Output: 4
Note:
1 <= K <= 1001 <= N <= 10000
第0-5层与5-10层的效果是一样的
https://leetcode.com/problems/super-egg-drop/discuss/159079/Python-DP-from-kn2-to-knlogn-to-kn
Here the dp formula is dp[k][n] = min(1 + max(dp[k - 1][i - 1], dp[k][n - i])) i = 1...n.
base case:
dp[0][i]=0, i=1...N # no egg, no floor can check
dp[1][i]=i, i=1...N # one egg, check floor from i to 1
dp[j][1]=1, j=1...K # one floor, only check once
First of all, we can come up with simple O(kn^2) solution as below:
class Solution(object):
def superEggDrop(self, K, N):
"""
:type K: int
:type N: int
:rtype: int
"""
dp=[[0]*(N+1) for _ in range(K+1)]
for i in range(1, N+1):
dp[1][i] = i
dp[0][i] = 0
for j in range(1, K+1):
dp[j][1] = 1
for i in range(2, K+1):
for j in range(2, N+1):
dp[i][j] = float('inf')
for x in range(1, j+1):
res = 1 + max(dp[i-1][j-x], dp[i][x-1])
dp[i][j]=min(dp[i][j], res)
return dp[-1][-1]
It gets TLE. To optimize, we can see for a fixed k, dp[k][n] goes up as n increases. This means dp[i-1][j-x] will decrease and dp[i][x-1] will increase as x goes from 1 to j. The optimal value of x will be the middle point where the two meets. So to get the optimal x value for dp[k][n] at a fixed k and n, we can do a binary search for x from 1 to n.
This will save the third for-loop for x from O(n) to O(logn). Total complexity is O(knlogn). Using binary seach, we can only do bottom up dp, as shown below:
class Solution(object):
def superEggDrop(self, K, N):
"""
:type K: int
:type N: int
:rtype: int
"""
def dp(k, n):
if k==1:
return n
if n==0:
return 0
if n==1:
return 1
if (k, n) in d:
return d[k, n]
lo, hi=0, n
while lo<hi:
mid=(lo+hi)/2
left, right=dp(k, mid-1), dp(k-1, n-mid)
if left<right:
lo=mid+1
else:
hi=mid
res=1+max(dp(k, lo-1), dp(k-1, n-lo))
d[k, n]=res
return res
d={}
return dp(K, N)
To go one step further, for a fixed k, we can see the optimal value of x for each dp[k][n] will increase as n increases. Therefore, once we get the optimal x for dp[k][n], we can save current x value and start the next round of for-loop directly, instead of initiating x from 0 again. In this way, in the third for-loop, x will go from 1 to N only once as j in the second for-loop goes from 1 to N. The total time complexity will be O(kn).
class Solution(object):
def superEggDrop(self, K, N):
"""
:type K: int
:type N: int
:rtype: int
"""
dp=[[0]*(N+1) for _ in range(K+1)]
for i in range(1, N+1):
dp[1][i] = i
dp[0][i] = 0
for j in range(1, K+1):
dp[j][1] = 1
for i in range(2, K+1):
x=1
for j in range(2, N+1):
while x<j+1:
if dp[i][x-1]>=dp[i-1][j-x]:
dp[i][j]=1 + max(dp[i-1][j-x], dp[i][x-1])
break
x+=1
return dp[-1][-1]