你将获得 K 个鸡蛋，并可以使用一栋从 1 到 N 共有 N 层楼的建筑。
每个蛋的功能都是一样的，如果一个蛋碎了，你就不能再把它掉下去。
你知道存在楼层 F ，满足 0 <= F <= N 任何从高于 F 的楼层落下的鸡蛋都会碎，从 F 楼层或比它低的楼层落下的鸡蛋都不会破。
每次移动，你可以取一个鸡蛋（如果你有完整的鸡蛋）并把它从任一楼层 X 扔下（满足 1 <= X <= N）。
你的目标是确切地知道 F 的值是多少。
无论 F 的初始值如何，你确定 F 的值的最小移动次数是多少？

示例 1：

  1. 输入：K = 1, N = 2
  2. 输出：2
  3. 解释：
  4. 鸡蛋从 1 楼掉落。如果它碎了，我们肯定知道 F = 0 。
  5. 否则，鸡蛋从 2 楼掉落。如果它碎了，我们肯定知道 F = 1 。
  6. 如果它没碎，那么我们肯定知道 F = 2 。
  7. 因此，在最坏的情况下我们需要移动 2 次以确定 F 是多少。

示例 2：

输入：K = 2, N = 6
输出：3

示例 3：

输入：K = 3, N = 14
输出：4


提示：

  1. 1 <= K <= 100

  2. 1 <= N <= 10000

    迭代法

    class Solution {
public:
 int calcF(int K, int T)
 {
     if (T == 1 || K == 1) return T + 1;
     return calcF(K - 1, T - 1) + calcF(K, T - 1);
 }

 int superEggDrop(int K, int N)
 {
     int T = 1;
     while (calcF(K, T) < N + 1) T++;
     return T;
 }
};


    class Solution {
public:
 int superEggDrop(int K, int N) {
     vector<vector<int>> dp(K+1, vector<int>(N+1, N+3));
     for(int i =1 ;i<=K;i++){
         for(int j = 0;j<=N;j++){
             dp[i][j] = j;
         }
     }
     for(int i = 0; i<=K;i++){
         dp[i][0] = 0;
     }
     for(int i =1 ;i<=K;i++){
         for(int j = 1;j<=N;j++){
             for(int k = 1; k<= j;k++){
                 dp[i][j] = min(dp[i][j], max(dp[i][j-k], dp[i-1][k-1]) + 1);
             }

         }
     }
     return dp[K][N];
 }
};