鸡蛋掉落
你将获得 K 个鸡蛋，并可以使用一栋从 1 到 N 共有 N 层楼的建筑。
每个蛋的功能都是一样的，如果一个蛋碎了，你就不能再把它掉下去。
你知道存在楼层 F ，满足 0 <= F <= N 任何从高于 F 的楼层落下的鸡蛋都会碎，从 F 楼层或比它低的楼层落下的鸡蛋都不会破。
每次移动，你可以取一个鸡蛋（如果你有完整的鸡蛋）并把它从任一楼层 X 扔下（满足 1 <= X <= N）。
你的目标是确切地知道 F 的值是多少。
无论 F 的初始值如何，你确定 F 的值的最小移动次数是多少？
示例 1：
输入：K = 1, N = 2
输出：2
解释：
鸡蛋从 1 楼掉落。如果它碎了，我们肯定知道 F = 0 。
否则，鸡蛋从 2 楼掉落。如果它碎了，我们肯定知道 F = 1 。
如果它没碎，那么我们肯定知道 F = 2 。
因此，在最坏的情况下我们需要移动 2 次以确定 F 是多少。
示例 2：
输入：K = 2, N = 6
输出：3
示例 3：
输入：K = 3, N = 14
输出：4
提示：
1 <= K <= 100
1 <= N <= 10000
笔记：
动态规划
动态规划解决问题的过程分为两步：
1.寻找状态转移方程式
2.利用状态转移方程式自底向上求解问题
假设我们第一个鸡蛋扔出的位置在第X层（1<=X<=M），会出现两种情况：
1.第一个鸡蛋没碎
那么剩余的M-X层楼，剩余N个鸡蛋，可以转变为下面的函数：
F（M-X，N）+ 1，1<=X<=M
2.第一个鸡蛋碎了
那么只剩下从1层到X-1层楼需要尝试，剩余的鸡蛋数量是N-1，可以转变为下面的函数：
F（X-1，N-1） + 1，1<=X<=M
我们需要求一个最优决策使得扔的次数最小，虽然实际扔的次数会随着真实结果而变化，但是k个鸡蛋来测N层可以借助于k-1个鸡蛋测N层的结果。
我们用dp[n][k]表示k个鸡蛋测n层的扔的次数。如果i层的时候鸡蛋碎了，剩下来的k-1个鸡蛋用来测i-1层，也就是dp[n][k]=dp[i-1][k-1]+1；如果i层的时候鸡蛋没有碎，那么剩下来的k个鸡蛋用来测n-i个楼层。所以，在第i层扔，会用 max(dp[i-1][k-1], dp[n-i][k]) + 1，即
dp[n][k]=min(max(dp[i−1][k−1],dp[n−i][k])+1)(1<=i<=n)
思路2：
https://www.cnblogs.com/yunlambert/p/10028865.html
我们可以改变一下求解的思路，求k个鸡蛋在m步内可以测出多少层：
假设: dp[k][m] 表示k个鸡蛋在m步内最多能测出的层数。
那么，问题可以转化为当 k <= K 时，找一个最小的m，使得dp[k][m]<= N。
我们来考虑下求解dp[k][m]的策略：
假设我们有k个鸡蛋第m步时，在第X层扔鸡蛋。这时候，会有两种结果，鸡蛋碎了，或者没碎。
如果鸡蛋没碎，我们接下来会在更高的楼层扔，最多能确定 X + dp[k][m-1] 层的结果；
如果鸡蛋碎了，我们接下来会在更低的楼层扔，最多能确定 Y + dp[k-1][m-1]层的结果 (假设在第X层上还有Y层)。
因此，这次扔鸡蛋，我们最多能测出 dp[k-1]m-1 + dp[k][m-1] (没摔碎时能确定的层数) + 1 (本层) 层的结果。
另外，我们知道一个鸡蛋一次只能测一层，没有鸡蛋一层都不能测出来。
因此我们可以列出完整的递推式:
dp[k][0] = 0
dp[1][m] = m (m > 0)
dp[k][m] = dp[k-1][m-1] + dp[k][m-1] + 1 (k > 0, m>0)
C++代码:
class Solution {
public:
int superEggDrop(int K, int N) {
if(K==0) return 0;
if(K==1) return N;
int dp[N+2][K+2];
memset(dp,0,sizeof(dp));
dp[0][0]=0;
for(int i=1;i<=N;++i)
{
dp[i][0]=0;
for(int j=1;j<=K;++j)
{
dp[i][j]=dp[i-1][j]+dp[i-1][j-1]+1;
if(dp[i][j]>=N)
return i;
}
}
return N;
}
};
python代码：
class Solution:
def superEggDrop(self, K: int, N: int) -> int:
dp = [[0 for i in range(N + 1)] for j in range(K + 1)]
for i in range(1,K+1):
for j in range(1,N+1):
dp[i][j] = dp[i-1][j-1] + (dp[i][j-1] + 1)
if dp[K][j] >= N:
return j
return 0