扔鸡蛋 （动态规划）

你将获得 K 个鸡蛋，并可以使用一栋从 1 到 N  共有 N 层楼的建筑。

每个蛋的功能都是一样的，如果一个蛋碎了，你就不能再把它掉下去。

你知道存在楼层 F ，满足 0 <= F <= N 任何从高于 F 的楼层落下的鸡蛋都会碎，从 F 楼层或比它低的楼层落下的鸡蛋都不会破。

每次移动，你可以取一个鸡蛋（如果你有完整的鸡蛋）并把它从任一楼层 X 扔下（满足 1 <= X <= N）。

你的目标是确切地知道 F 的值是多少。

无论 F 的初始值如何，你确定 F 的值的最小移动次数是多少？

/*  不能简单的用二分法： eg: 如果只有两个蛋 第一个碎了之后第二个应该尽可能谨慎 如从第一层重新开始
 *  显然 蛋越多（足够多）可以用二分 即最短的移动步数最好在最后一步移动时碎掉所有的蛋
 *  方法1： dp[n][k] 为剩余k个蛋去探测n层楼最少的步数 dp[i][1]=i
 *         考虑在第i层仍（反正要遍历）分为两种情况 （具体步数根当前情况有关 但是要考虑最坏的情况 就取下面最大的）
 *         1. 没碎 dp[n-i][k]
 *         2. 碎了 dp[i-1][k-1]
 *
 *         考虑最坏的情况 即： max(dp[n-i][k]， dp[i-1][k-1])+1 1是当前这一步
 *         注意这里是考虑仍在第i层 因此会有一个最好的情况出现
 *         dp[n][k] = min{ max(dp[i-1][k-1], dp[n-i][k]) + 1 } (1 <= i <= n)
 * */
class Solution {
public:
    int superEggDrop(int K, int N) {
        vector<vector<int>> dp(N+1, vector<int>(K+1, 0));
        // 边界dp[i][0]=0, dp[i][1]=i
        for(int i=0;i<=N;i++){
            dp[i][1] = i;
        }
        // 注意 这里dp[n][k]一定要理解为用k个蛋去探测n层（而非第n层）
        for(int j=2;j<=K;j++){
            for(int i=1;i<=N;i++){
                dp[i][j] = i; // 最多需要的步数 赋格初值
                // 当前有j个蛋 楼层一共有i层的情况  针对扔在第k层的情况进行分析
                for(int k=i;k<=i;k++){
                    dp[i][j] = min(dp[i][j], max(dp[k-1][j-1], dp[i-k][j])+1);
                }
            }
        }
        return dp[N][K];
    }
};

/*  
 *  思路2： 求k个鸡蛋在m步内最多测出来的层数
 *         dp[m][k]
 *         假设当前站在第i层 仍一个蛋 碎了则可以测dp[m-1][k-1]（向本层以下测）
 *                                没碎可以测 dp[m-1][k](向本层以上测)
 *                                加上本层这个鸡蛋也可以定一层？
 *                                dp[m][k] = dp[m-1][k-1]+dp[m-1][k]+1
 *                                甚至可以优化空间复杂度（用到的都是dp[m-1]这种）注意这里是k-1所以循环顺序注意下
 * */
class Solution {
public:
    int superEggDrop(int K, int N) {
        vector<int> dp(K+1, 0);
        int m;
        for(m=0;dp[K]<N;m++){
            for(int k=K;k>0;k--){ // dp[m][k] = dp[m-1][k-1]+dp[m-1][k]+1 因为是k-1所以注意覆盖顺序应该是从后向前
                dp[k] += dp[k-1] + 1;
            }
        }
        return m;
    }
};