【动态规划】鸡蛋掉落_给你 2 枚相同 的鸡蛋,和一栋从第 1 层到第 n 层共有 n 层楼的建筑。 js

887. 鸡蛋掉落

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

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

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

请你计算并返回要确定 f 确切的值 的 最小操作次数 是多少？

实现一，普通动态规划，难点在状态转移方程以及dp的定义。时间复杂度O(kn^2) ，n=10000时，超时

int superEggDrop1(int k, int n) {
    /*
        dp[i][j]表示剩余i枚鸡蛋，共有j层楼的最坏情况下的最小操作次数
        base case: dp[i][0] =0, dp[0][j]=n 
        选择：则第i枚鸡蛋可以从1~j层楼任意层楼m扔下（暴力枚举）
        状态转移：dp[i][j] = min(dp[i][j],max(dp[i][j-m],dp[i-1][m-1])+1)
                                                  没碎      碎了
                  dp[i][j] 默认取j，表示从一楼线性往上扫描（最慢的方式）

        */
    vector<vector<int>> dp(k+1,vector<int>(n+1,n));
    for(int i=1; i<=k; i++){
        dp[i][0]=0;
    }
    for(int i=1;i<=k;i++){
        for(int j=1; j<=n;j++){
            dp[i][j] = j;
            for(int m = 1;m<=j;m++){
                dp[i][j] = min(dp[i][j],max(dp[i][j-m],dp[i-1][m-1])+1);
            }
        }
    }
    return dp[k][n];
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

实现二：对上面的实现进行优化，使用二分搜索。时间复杂度O(kn logn),勉强通过

int superEggDrop(int k, int n) {
    /*
           以上算法时间复杂度O(k*n*n)，n=10000时超时了。
           主要原因是这个n*n，m每次取值都是1~j，因此需要想办法减少不必要的取值。
           在max(dp[i][j-m],dp[i-1][m-1])中，如果取的是前者，则说明蛋没碎，应该往高处走。
           如果是后者则蛋碎了，因该往低处走。可以考虑使用二分搜索的方式选择走哪一层。
           i>1，才能使用二分搜索
        */
    vector<vector<int>> dp(k+1,vector<int>(n+1,n));
    for(int i=1; i<=k; i++){
        dp[i][0]=0;
    }
    for(int i=1;i<=k;i++){
        for(int j=1; j<=n;j++){
            dp[i][j] = j;
            if(i==1){
                // i==1，只能线性遍历
                continue;
            }else{
                int lo=1, hi=j;
                while(lo <= hi){
                    int m = (lo+hi)/2;
                    if(dp[i][j-m]>dp[i-1][m-1]){
                        // 蛋没碎, 往上二分搜索
                        dp[i][j] = min(dp[i][j],dp[i][j-m]+1);
                        lo = m+1;

                    } else {
                        dp[i][j] = min(dp[i][j],dp[i-1][m-1]+1);
                        hi = m-1;
                    }
                }
            }

        }
    }
    return dp[k][n];
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38