887. 鸡蛋掉落(困难)-动态规划

一、题目描述

给你 k 枚相同的鸡蛋，并可以使用一栋从第 1 层到第 n 层共有 n 层楼的建筑。

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

每次操作，你可以取一枚没有碎的鸡蛋并把它从任一楼层 x 扔下（满足 1 <= x <= n）。如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。

请你计算并返回要确定 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

二、解题

动态规划

逆向思维：
如果我们可以做 t 次操作（扔t次鸡蛋），而且有 k 个鸡蛋，那么我们能找到答案的最高的 n （楼层数）是多少？

设 f(t, k) 为在上述条件下的 n。如果我们求出了所有的 f(t, k)，那么只需要找出最小的满足 f(t, k) ≥ n 的 t。

如何求出 f(t, k) 呢？还是使用动态规划。因为我们需要找出最高的 n，因此我们不必思考到底在哪里扔这个鸡蛋，我们只需要扔出一个鸡蛋，看看到底发生了什么：

• 如果鸡蛋没有碎，那么对应的是 f(t - 1, k)，也就是说在这一层的上方可以有 f(t - 1, k) 层；

• 如果鸡蛋碎了，那么对应的是 f(t - 1, k - 1)，也就是说在这一层的下方可以有 f(t - 1， k - 1)层。

其他解释：

1. 无论你在哪层楼扔鸡蛋，鸡蛋只可能摔碎或者没摔碎，碎了的话就测楼下，没碎的话就测楼上。

2. 无论你上楼还是下楼，总的楼层数 = 楼上的楼层数 + 楼下的楼层数 + 1（当前这层楼）。

根据这个特点，可以写出下面的状态转移方程：

f(t,k)=1+f(t−1,k−1)+f(t−1,k)

• 鸡蛋没有碎: f(t - 1, k)就是楼上的楼层数，因为鸡蛋个数 k 不变，也就是鸡蛋没碎，扔鸡蛋次数 m 减一；当前楼层没有碎，所以就想试着往上爬扔鸡蛋，看能不能碎，此时鸡蛋一个没碎为K个，但是扔的次数已经少一步了。

• f(t - 1, k - 1) 就是楼下的楼层数，因为鸡蛋个数 k 减一，也就是鸡蛋碎了，同时扔鸡蛋次数 m 减一。当前楼层碎了，就想往下爬，鸡蛋-1，扔的次数-1，找这种情况下最大的楼层数。此时鸡蛋碎了一个，扔的次数也少了一个，所以就计算下面的层数。

class Solution {
    public int superEggDrop(int k, int n) {
        if(n==1){
            return 1;
        }     
        int[][] dp = new int[n+1][k+1];      
        for(int i = 1;i<=k;i++){
            dp[1][i] = 1;
        }
        int res = 1;
        for(int i = 2;i<=n;i++){
            for(int j = 1;j<=k;j++){
                dp[i][j] = 1+dp[i-1][j-1]+dp[i-1][j];
            }
            if(dp[i][k] >= n){
                res = i;
                break;
            }
        }
        return res;
    }
}

时间复杂度：O(kn)；

空间复杂度：O(kn)。

另种答案

class Solution {
    public int superEggDrop(int k, int n) {
        //定义dp[k][m]表示k个鸡蛋在m步内可以测试的层数
        //当在第i层扔一个鸡蛋，使用了一步，有两种情况：
        //1.鸡蛋碎了：上面的楼层测试完毕，接下来在更低的楼层试，最多能测试N-i+dp[k-1][m-1]层；
        //2.鸡蛋没碎：下面的楼层测试完毕，接下来在更高的楼层试，最多能测试i-1+dp[k][m-1]层；
        //因此如果有k个鸡蛋和m步，并且在第i层仍鸡蛋，最多可测试的层数：
        //dp[k-1][m-1]+dp[k][m-1]+1
        //可以用一维数据代替二维dp
        int[] dp = new int[k + 1];
        for(int step = 1; step <= n; step++) {
            for(int i = k; i > 0; i--){
                dp[i] = dp[i - 1] + dp[i] + 1;
                if (dp[i] >= n) {
                    return step;
                }
            }
        }
        return n;
    }
}