LeetCode887

// class Solution {
//     public int superEggDrop(int K, int N) {

//         /* 超出时间限制
//         int[][] dp = new int[K+1][N+1];
//         for (int i = 0; i <= K; i++) {
//             for(int j = 0;j<=N;j++){
//                 dp[i][j] = 99999;
//             }
//         }
//         //base
//          // 初始化：填写下标为 0、1 的行和下标为 0、1 的列
//         // 第 0 咧：楼层为 0 的时候，不管鸡蛋个数多少，都测试不出鸡蛋的 F 值，故全为 0
//         for (int j = 0; j <= K; j++) {
//             dp[j][0] = 0;
//         }

//         // 第 1 列：楼层为 1 的时候，0 个鸡蛋的时候，扔 0 次，1 个以及 1 个鸡蛋以上只需要扔 1 次
//         dp[0][1] = 0;
//         for (int j = 1; j <= K; j++) {
//             dp[j][1] = 1;
//         }

//         // 第 0 行：鸡蛋个数为 0 的时候，不管楼层为多少，也测试不出鸡蛋的 F 值，故全为 0
//         // 第 1 行：鸡蛋个数为 1 的时候，这是一种极端情况，要试出 F 值，最少次数就等于楼层高度（想想复杂度的定义）
//         for (int i = 0; i <= N; i++) {
//             dp[0][i] = 0;
//             dp[1][i] = i;
        
//         }


//         //状态转移
//         for(int i =2;i<=K;i++){
//             for(int j = 2;j<=N;j++){
//                for (int k = 1; k <= j; k++) {
//                     // 碎了，就需要往低层继续扔：层数少 1 ，鸡蛋也少 1
//                     // 不碎，就需要往高层继续扔：层数是当前层到最高层的距离差，鸡蛋数量不少
//                     // 两种情况都做了一次尝试，所以加 1
//                     dp[i][j] = Math.min(dp[i][j], Math.max(dp[i - 1][k - 1], dp[i][j-k]) + 1);
//                 }
                
//             }
//         }
//         return dp[K][N];
//         */
//     }
// }


/*抄的
dp[k][m] = n
# 当前有 k 个鸡蛋，可以尝试扔 m 次鸡蛋
# 这个状态下，最坏情况下最多能确切测试一栋 n 层的楼

# 比如说 dp[1][7] = 7 表示：
# 现在有 1 个鸡蛋，允许你扔 7 次;
# 这个状态下最多给你 7 层楼，
# 使得你可以确定楼层 F 使得鸡蛋恰好摔不碎
# （一层一层线性探查嘛）*/

        class Solution {
    public int superEggDrop(int K, int N) {
        int[][] dp = new int[K + 1][N + 1];
        for (int m = 1; m <= N; m++) {
            dp[0][m] = 0; // zero egg
            for (int k = 1; k <= K; k++) {
                dp[k][m] = dp[k][m - 1] + dp[k - 1][m - 1] + 1;
                if (dp[k][m] >= N) {
                    return m;
                }
            }
        }
        return N;
    }
}