鸡蛋的硬度（扔鸡蛋问题）

注：本文章介绍了多种方法，若想要看AC思路和代码，请直接看第七、八种方法

描述

最近XX公司举办了一个奇怪的比赛：鸡蛋硬度之王争霸赛。参赛者是来自世界各地的母鸡，比赛的内容是看谁下的蛋最硬，更奇怪的是XX公司并不使用什么精密仪器来测量蛋的硬度，他们采用了一种最老土的办法--从高度扔鸡蛋--来测试鸡蛋的硬度，如果一次母鸡下的蛋从高楼的第a层摔下来没摔破，但是从a+1层摔下来时摔破了，那么就说这只母鸡的鸡蛋的硬度是a。你当然可以找出各种理由说明这种方法不科学，比如同一只母鸡下的蛋硬度可能不一样等等，但是这不影响XX公司的争霸赛，因为他们只是为了吸引大家的眼球，一个个鸡蛋从100 层的高楼上掉下来的时候，这情景还是能吸引很多人驻足观看的，当然，XX公司也绝不会忘记在高楼上挂一条幅，写上“XX公司”的字样--这比赛不过是XX 公司的一个另类广告而已。

勤于思考的小A总是能从一件事情中发现一个数学问题，这件事也不例外。“假如有很多同样硬度的鸡蛋，那么我可以用二分的办法用最少的次数测出鸡蛋的硬度”，小A对自己的这个结论感到很满意，不过很快麻烦来了，“但是，假如我的鸡蛋不够用呢，比如我只有1个鸡蛋，那么我就不得不从第1层楼开始一层一层的扔，最坏情况下我要扔100次。如果有2个鸡蛋，那么就从2层楼开始的地方扔……等等，不对，好像应该从1/3的地方开始扔才对，嗯，好像也不一定啊……3个鸡蛋怎么办，4个，5个，更多呢……”，和往常一样，小A又陷入了一个思维僵局，与其说他是勤于思考，不如说他是喜欢自找麻烦。

好吧，既然麻烦来了，就得有人去解决，小A的麻烦就靠你来解决了：

输入描述

输入包括多组数据，每组数据一行，包含两个正整数n和m(1≤n≤100,1≤m≤10)，其中n表示楼的高度，m表示你现在拥有的鸡蛋个数，这些鸡蛋硬度相同（即它们从同样高的地方掉下来要么都摔碎要么都不碎），并且小于等于n。你可以假定硬度为x的鸡蛋从高度小于等于x的地方摔无论如何都不会碎（没摔碎的鸡蛋可以继续使用），而只要从比x高的地方扔必然会碎。

对每组输入数据，你可以假定鸡蛋的硬度在0至n之间，即在n+1层扔鸡蛋一定会碎。

输出描述

对于每一组输入，输出一个整数，表示使用最优策略在最坏情况下所需要的扔鸡蛋次数。

用例输入 1

100 1
100 2

用例输出 1

100
14

提示

最优策略指在最坏情况下所需要的扔鸡蛋次数最少的策略。
如果只有一个鸡蛋，你只能从第一层开始扔，在最坏的情况下，鸡蛋的硬度是100，所以需要扔100次。如果采用其他策略，你可能无法测出鸡蛋的硬度(比如你第一次在第二层的地方扔,结果碎了,这时你不能确定硬度是0还是1)，即在最坏情况下你需要扔无限次，所以第一组数据的答案是100。

一、题目再抽象

• 建筑：共 n 层，编号 1 … n

• 鸡蛋：共 k 枚，完全相同

• 硬度 x：

  • 在 ≤ x 层扔 → 不碎，可继续用

  • 在 > x 层扔 → 必碎，消耗 1 枚

• 目标：在最坏情况下确定 x 所需的最少扔蛋次数

---

二、符号统一

符号	含义
k	鸡蛋数
n	楼层数
t	扔蛋次数

---

三、方法 1：暴力递归（指数级）

1. 子问题定义

dfs(k, n)：k 蛋 n 层的最少次数

2. 转移方程

枚举第一次扔的楼层 f（1 ≤ f ≤ n）：

dfs(k, n) = 1 + min{ max(dfs(k-1, f-1), dfs(k, n-f)) }

• 碎：剩下 k-1 蛋，下方 f-1 层

• 不碎：仍有 k 蛋，上方 n-f 层
  取两者最大值（最坏情况），再在所有 f 里取最小（最优策略）

3. 边界

• n == 0 → 0

• n == 1 → 1

• k == 1 → n（只能线性扫）

4. 代码

int dfs(int k, int n) {
    if (n == 0) return 0;
    if (n == 1) return 1;
    if (k == 1) return n;
    int ans = INT_MAX;
    for (int f = 1; f <= n; ++f) {
        int worst = 1 + max(dfs(k-1, f-1), dfs(k, n-f));
        ans = min(ans, worst);
    }
    return ans;
}

5. 复杂度

• 状态数：k·n

• 每状态转移：O(n)

• 总时间：O(k·n²)，但无记忆化导致实际指数爆栈

---

四、方法 2：记忆化搜索（Top-down DP）

1. 改动点

加 memo[k][n] 缓存，其余与方法 1 完全一致

2. 代码

int memo[11][101];
int dfs(int k, int n) {
    if (n == 0) return 0;
    if (n == 1) return 1;
    if (k == 1) return n;
    int &v = memo[k][n];
    if (v != -1) return v;
    v = INT_MAX;
    for (int f = 1; f <= n; ++f)
        v = min(v, 1 + max(dfs(k-1, f-1), dfs(k, n-f)));
    return v;
}

3. 复杂度

• 时间：O(k·n²)

• 空间：O(k·n)

---

五、方法 3：二维递推（Bottom-up DP）

1. 数组定义

dp[i][j]：i 蛋 j 层的最少次数

2. 转移

dp[i][j] = 1 + min_{1≤f≤j} max(dp[i-1][f-1], dp[i][j-f])

3. 填表顺序

外层 i 从 2 到 k，内层 j 从 2 到 n，最内层 f 从 1 到 j

4. 代码

int dp[11][101];
int eggDrop(int k, int n) {
    for (int i = 1; i <= k; ++i) dp[i][0] = 0, dp[i][1] = 1;
    for (int j = 1; j <= n; ++j) dp[1][j] = j;

    for (int i = 2; i <= k; ++i)
        for (int j = 2; j <= n; ++j) {
            dp[i][j] = INT_MAX;
            for (int f = 1; f <= j; ++f)
                dp[i][j] = min(dp[i][j],
                               1 + max(dp[i-1][f-1], dp[i][j-f]));
        }
    return dp[k][n];
}

5. 复杂度

• 时间：O(k·n²)

• 空间：O(k·n)

---

六、方法 4：二分优化 DP

1. 关键观察

固定 i,j，函数
g(f) = max(dp[i-1][f-1], dp[i][j-f]))

• dp[i-1][f-1] 随 f 单调增

• dp[i][j-f] 随 f 单调减
  g(f) 先减后增，极小值在两者交点附近，可二分

2. 二分过程

lo = 1, hi = j

• mid = (lo+hi)/2

• 若 dp[i-1][mid-1] > dp[i][j-mid] → 交点在左半，否则右半

• 更新 ans = min(ans, max(...)+1)

3. 代码

int dp[11][101];
int eggDrop(int k, int n) {
    for (int i = 1; i <= k; ++i) dp[i][0] = 0, dp[i][1] = 1;
    for (int j = 1; j <= n; ++j) dp[1][j] = j;

    for (int i = 2; i <= k; ++i)
        for (int j = 2; j <= n; ++j) {
            int lo = 1, hi = j, ans = INT_MAX;
            while (lo <= hi) {
                int mid = (lo + hi) / 2;
                int broken = dp[i-1][mid-1];
                int safe   = dp[i][j-mid];
                if (broken > safe) {
                    hi = mid - 1;
                    ans = min(ans, broken + 1);
                } else {
                    lo = mid + 1;
                    ans = min(ans, safe + 1);
                }
            }
            dp[i][j] = ans;
        }
    return dp[k][n];
}

4. 复杂度

• 时间：O(k·n·log n)

• 空间：O(k·n)

---

七、方法 5：数学反转 + 一维递推（最优实战）

1. 反向提问

用 k 蛋扔 t 次，最多能测多少层？
记 dp[i] 为 i 蛋当前次数下的最大覆盖层数

2. 状态转移

dp[i] += 1 + dp[i-1]

• 1：当前测试层

• dp[i-1]：鸡蛋碎了，下面还能测的层数

• dp[i]：鸡蛋没碎，上面还能测的层数

3. 流程

• t = 0

• 循环直到 dp[k] ≥ n：

  • t++

  • 倒序更新 dp[i] += 1 + dp[i-1]

4. 代码

const int N = 110;
int eggdrop(int k, int n) {
    int dp[N] = {0};
    int t = 0;
    while (dp[k] < n) {
        ++t;
        for (int i = k; i > 0; --i)
            dp[i] += 1 + dp[i-1];
    }
    return t;
}

5. 运行轨迹（k=2, n=100）

t	dp[1]	dp[2]	dp[2] 含义
1	1	2	2 层
2	2	4	4 层
3	3	7	7 层
…	…	…	…
14	14	105	≥100 → 停止

返回 t = 14

6. 复杂度

• 时间：O(t·k)，t ≈ √(2n)，实际 ≤14（n=100）

• 空间：O(k)

---

八、方法 6：组合数二分（理论最快）

1. 数学公式

k 蛋 t 次最多覆盖：

C(t,1) + C(t,2) + … + C(t,k)

二分 t 使上式 ≥ n

2. 代码

int superEggDrop(int k, int n) {
    auto cover = [&](int t) {
        long long s = 0, c = 1;
        for (int i = 1; i <= k; ++i) {
            c = c * (t - i + 1) / i;   // 组合数 C(t,i)
            s += c;
            if (s >= n) return true;
        }
        return s >= n;
    };
    int lo = 1, hi = n;
    while (lo < hi) {
        int mid = (lo + hi) / 2;
        if (cover(mid)) hi = mid;
        else lo = mid + 1;
    }
    return lo;
}

3. 复杂度

• 时间：O(k·log n)

• 空间：O(1)

---

九、方法对比总表

方法	时间	空间	代码行	适用场景
1 暴力递归	O(k·n²) 状态·O(n) 转移	O(k·n)	短	理解题意
2 记忆化	O(k·n²)	O(k·n)	短	面试快速
3 二维 DP	O(k·n²)	O(k·n)	中等	考试稳妥
4 二分优化	O(k·n·log n)	O(k·n)	较长	竞赛常用
5 一维反转	O(t·k)≈O(k√n)	O(k)	极简	实战最优
6 组合数二分	O(k·log n)	O(1)	短	理论极限

---

十、结论

• 学习路线：1→2→3→5 即可掌握全部核心思想

• 竞赛/面试现场：直接写方法 5，代码最短、效率最高

• 需要理论最优：方法 6 提供 O(k log n) 极限复杂度