数据结构与算法 #4 高楼丢鸡蛋(源自谷歌面试题)

1,430 阅读10分钟

⭐️ 本文已收录到 AndroidFamily,技术和职场问题,请关注公众号 [彭旭锐] 和 [BaguTree Pro] 知识星球提问。

学习数据结构与算法的关键在于掌握问题背后的算法思维框架,你的思考越抽象,它能覆盖的问题域就越广,理解难度也更复杂。在这个专栏里,小彭将基于 Java / Kotlin 语言,为你分享常见的数据结构与算法问题,及其解题框架思路。

本文是数据结构与算法系列的第 4 篇文章,完整文章目录请移步到文章末尾~

历史上的今天

2000 年 3 月 12 日,万维网诞生的标志性文件出现。 在 CERN(欧洲核子研究中心)工作的伯纳斯·李给上司提交了一份建议书,名为《关于信息化管理的建议》("Information Management: A Proposal"),它拉开了万维网等待序幕。—— 《了不起的程序员》


前言

  • 高楼丢鸡蛋问题可以说是比较有名的面试题了,最初出自谷歌的面试题。在这篇文章里,我将分享我的思考 & 学习过程,如果能帮上忙,请务必点赞加关注,这真的对我非常重要。

目录


1. 问题描述

这道题在 LeetCode 有对应的题目:887. Super Egg Drop 鸡蛋掉落 【题解】,简单来说:给定 N 层楼和 K 个鸡蛋,要求找到扔下鸡蛋不碎的最高楼层(临界楼层 F),那么最少尝试几次一定能找到这个临界楼层?其中:N1N \geq 1K1K \geq 10FN0 \leq F \leq N,比较常见的情况是 N = 100,K = 2,也就是所谓的双蛋问题

这道题是在问:最坏情况下最少的尝试次数

举个例子,有 100 层楼和 1 个鸡蛋,这个时候,无非是在 [1,100] 中任意找第 k 层丢一下,如果没碎说明 F 在 [k,100] 的楼层中,如果碎了,说明 F 在 [1,k - 1] 的楼层中间,但是因为没有更多的鸡蛋了,此时就无法继续找到临界楼层 F 了。

所以,只有一个鸡蛋的时候就要悠着点用了,只能从一楼依次往高楼层尝试,运气最好的情况下,鸡蛋在一楼就碎了,F 就是 1,尝试 1 次;运气最坏情况下,鸡蛋在 100 楼才碎,F 就是 100,尝试 100 次。

由于在尝试之前,临界楼层 F 是未知的。因此,为了兼容 F 的每种情况,只有做最坏的打算(使用最坏情况的尝试次数),才能确保一定能找到临界楼层。否则,假如只给 50 次尝试机会,在 F = 1 时可以找到,但是当 F 属于 [51,100] 时,尝试次数就不够了。


2. 边界测试用例

我们先看分析一些简单的边界条件:

  • N = 1

只有一层楼的情况,只需要尝试 1 次就可以知道 F = 0 还是 F = 1;

  • K = 1,N = *

只有一个鸡蛋,从最低层往最高层线性搜索,最少尝试次数等于楼层数 N,这个结论我们在 第 1 节,已经讨论过,相信你已经明白了;

  • K > N

鸡蛋数大于等于楼层数的情况,其他文章里会说成鸡蛋数无穷大,其实不需要那么多鸡蛋,只要足够每一层都丢一次就行。这种情况可以使用很常见的二分搜索算法,即:从中间楼层丢一下,如果碎了则下楼,如果没碎则上楼,每次尝试后楼层数都少了一半,知道最后只剩下一层楼,如果没碎它就是 F ,否则它的下一层是 F。

将整个过程画成一棵递归树如下图所示:

那么,总共尝试了多少步呢?其实,尝试步数就刚好等于这棵树的高度。由于叶子节点有 101 个(0FN0 \leq F \leq N),所以树的高度 h 要满足:2h>=1012^h >= 101 才能保证覆盖 F 的每种情况,即:h>=log21016.66h >= \log_2 101 \approx 6.66,向上取整,结论是最少需要尝试 7 次。

提示: 看了李永乐老师那期视频的同学,也许会认为这里讲错了。需要注意的是,在李永乐老师描述的那道题里,1FN1 \leq F \leq N,自然树的高度 h>=log2Nh >= \log_2 N;而 LeetCode 这道题目描述 F 可以等于 0, 多了一个 0 节点,所以应 h>=log2(N+1)h >= \log_2 (N + 1)

  • K = 0 没有更多鸡蛋,很明显问题无解,虽然题目已经明确告知 K > 0,但是我们要留意我们的算法中会不会出现 K = 0 的情况

3. 双蛋问题

最常见的问法是 N = 100,K = 2,也是就所谓的双蛋问题。跟只有 1 蛋相比,2 个鸡蛋可谓是富足,这个时候就没必要如履薄冰地线性搜索了,步子可以大一点。比如说:

  • 等间隔丢

第一个鸡蛋可以每隔 10 层丢一次:10、20、30...100,如果碎了第二个鸡蛋再从前面的 9 层线性搜索。比如说第一个蛋在 10 层碎了,那么第二个蛋就在 [1,9] 之间试,也就是:

第一个鸡蛋尝试:10 20 30 40 50 60 70 80 90 100(最多尝试 10 次) 第二个鸡蛋最多尝试 9 次

因此,总的来说,最好的情况是第一个蛋在第 10 层就碎了,总次数是 10 次,最坏的情况是第一个蛋在第 100 层碎,总的次数就是 19 次。最好和最坏的情况相差比较大,这是因为第一个蛋每次都是等间隔丢,所以第二个蛋丢的时候,无论如何最坏都要尝试 9 次。

  • 不等间隔丢

使用等间隔丢的方法,如果间距取得比较大,当第一个蛋碎的时候,第二个蛋要试的次数就比较大;当间距取比较小的时候,当 F 的位置越靠后,第一个蛋要试的次数就越大。

有没有办法让两个蛋丢的次数均衡一下呢,试试刚开始的时候间距取大一些,越往后间距逐渐缩小。即:第一次的间隔 为 n,如果没碎第二次的间隔为 n...,一直到最后一层间隔为 1。使用高斯公式可以知道n(n+1)/2=100n*(n+1)/2 = 100,则n13.65n \approx 13.65,向上取整 n 等于 14,也就是:

第一个鸡蛋尝试:14 27 39 50 60 89 77 84 90 95 99 100(最多尝试12次) 第二个鸡蛋最多尝试的区间是 [1,13],一共是13次

因此,总的来说,最好的情况是 12 次,最坏的情况是 14次。相对于等间距的 10 - 19 次要平均一些了,最坏情况的次数也更少。


4. 问题建模

经过前面的讨论,我们已经找到了尝试 14 次一定能解决双蛋问题的算法,但是这种算法就一定是最好的吗?为了验证 & 找到最好的方法,我们应使用动态规划去思考这个问题,对于动态规划我们已经有了一套解题模板了,一步步来呗:

第一步:定义问题:

回到最初的问题,给定 NN 层楼和 KK 个鸡蛋,要求找到扔下鸡蛋不碎的最高楼层(临界楼层 FF),那么最少尝试几次一定能找到这个临界楼层?我们可以定义问题如下:给定输入 NNKK,输出为最少尝试次数 YY,即: Y=dp(N,K)Y = dp(N,K)

假设在第 ii 楼尝试,会存在两种情况(碎和不碎):

  • 如果碎了,需要在低楼层 [1,i1][1,i - 1] 搜索,问题规模缩小为:y1=dp(i1,K1)y_1 = dp(i - 1,K - 1)
  • 如果没碎,需要在高楼层 [i1,N][i - 1,N] 搜索,问题规模缩小为:y2=dp(Ni,K)y_2 = dp(N - i,K)

提示: [1,10][1,10] 层 2 个鸡蛋[11,20][11,20] 层 2个鸡蛋,两个问题是等价的,都是Y=dp(10,2)Y = dp(10,2),问题的关键是楼层数量和鸡蛋个数,而不是楼层编号,很好理解,对吧。

因此,对于在第 i 楼的尝试,最坏情况下的尝试次数 Yi=max(y1,y2)Y_i = max(y_1,y_2)。而 ii 可以在 [1,N][1,N] 中选择一个,根据题意,我们要找出这 NN 种选择里最少的尝试次数,即:

Y=min1iNYi+1=min1iN(max{dp(i1,K1),dp(Ni,K)})+1Y = \min_{1\leq i \leq N} Y_i + 1 = \min_{1\leq i \leq N} (max{\{dp(i - 1,K - 1),dp(N - i,K)\})} + 1

提示:加 1 是因为划分子问题的时候也丢了一次。

第二步:检查重叠子问题:

这个问题是存在重叠子问题的,例如前面说的 [1,10] 层 2 个鸡蛋[11,20] 层 2个鸡蛋,两个问题是等价的,问题的关键是楼层数量和鸡蛋个数,而不是楼层编号。假如我们曾经计算过函数值 YN=10,K=2Y_{N=10,K=2},那么下一次遇到 N = 10,K = 2 的问题,就可以直接返回前者的答案。

为此,我们需要使用 “备忘录” 把前者的答案记忆起来。用程序实现无非是基于数组或者基于散列表,这里使用二维数组即可:

K 行 N 列(鸡蛋的数目较少,作为行)
val dp = Array(K + 1) {
    IntArray(N + 1) { -1 }
}

提示: dp 数组的初始值可以是 0、-1 或其它,根据具体问题选择最方便的数值即可。通常来说,-1 带有:“这里有个值,但是不会真正去读取它” 这样的含义。

第三步:尝试编码:

到这里,基本可以写代码了。可以看到,除开边界代码,这么复杂的问题的核心的部分不过 10 行 【题解】

class Solution {
    fun superEggDrop(K: Int, N: Int): Int {

        // K 行 N 列(鸡蛋的数目较少,作为行)
        val dp = Array(K + 1) {
            IntArray(N + 1) { -1 }
        }

        fun dp(K: Int, N: Int): Int {
            // 1、边界测试用例
            if (N <= 2) {
                // 边界1. 空楼/一层楼/两层楼的情况
                return N
            }
            if (K == 1) {
                // 边界2. 只有一个鸡蛋,只能线性搜索
                return N
            }
            if (K >= N) {
                // 边界3,鸡蛋“充足”,使用二分搜索
                return log2(N + 1) // 树的高度要能覆盖[0,N] 共 N + 1 个叶子节点
            }
            if (K == 0) {
                // 边界4,没有鸡蛋
                return 0
            }

            // 2、重叠子问题
            if (-1 != dp[K][N]) {
                return dp[K][N]
            }
            // 3、动态规划
            var y_k_n = Integer.MAX_VALUE
            for (i in 1..N) {
                val y_i = Math.max(
                    dp(K - 1, i - 1),// 碎 -> [1,i - 1]
                    dp(K, N - i) // 没碎 -> [i - 1, N]
                )
                y_k_n = Math.min(y_k_n, y_i)
            }
            // 加一是因为划分子问题时丢了一次
            return (y_k_n + 1).apply {
                dp[K][N] = this
            }
        }
        return dp(K, N).apply{
            for(n in 0 .. K){
                System.out.println("n = $n = " + dp[n].joinToString())
            }
        }
    }

    // 以 2 为底的对数
    private fun log2(n: Int) = Math.ceil(Math.log(n.toDouble()) / Math.log(2.0)).toInt() // 向上取整
}

我们分析下算法复杂度:

  • 时间复杂度 这是一个递归问题,递归问题的时间复杂度 = 子问题个数 x 递归函数本身的时间复杂度。其中,子问题个数就是不同 N & K的状态组合,总共有 NKNK 种;而递归函数里有一个 for 循环,每一轮循环里比较了碎与不碎两种情况的最大值,因此递归函数本身的时间复杂度是O(n)O(n),综上,总的时间复杂度就是O(KN2)O(KN^2)

  • 空间复杂度 使用了二维数组,空间复杂度是 O(KN)O(KN)

可以看到,这个解法的时间复杂度是O(n2)O(n^2)级的,比较高,无法通过全部测试用例,需要想优化方法。

image.png

第四步:优化:

基本优化的方法就是对递归树进行剪枝,在这篇文章里,我们专门总结过:数据结构与算法 #6 回溯算法解题框架总结,请关注!一步步来呗:

  • 重复状态

两个完全相同的状态最终得到的结果一定是一样的。这道题确实是存在重复状态,正如前面分析的,楼层数量和鸡蛋个数相同的问题,答案是一样。重复状态在 第二步:检查重叠子问题 已经优化过了。

  • 最终解确定

当我们在一个选择的分支中确定了最终解后,就没必要去尝试其他的选择了。这道题没有找到这样的判断方法。

  • 无效选择

当我们可以根据已知条件判断某个选择无法找到最终解时,就没必要去尝试这个选择了。那么,有这样的已知条件吗?有,比较隐晦的。观察上一节我们定义的问题:

Y=dp(N,K)=min1iNYi+1Y = dp(N,K)= \min_{1\leq i \leq N} Y_i + 1

dpdp 函数里,参数是 NNKK,因为我试图解决任意楼层任意鸡蛋数的问题,对吗。但是对于具体的某一个问题(比如双蛋问题),我们就应该把 NNKK 看作常量,为了方便你理解,下面我会用NcN_cKcK_c 表示,提醒你这是个常量,即:

Y=f(i)=min1iNcYi+1Y = f(i) = \min_{1\leq i \leq N_c} Y_i + 1

可以看出,这个问题里的变量其实只有一个 ii,表示第一步的选择楼层(最开始输入的最大规模问题),YiY_i是一个递归的问题,表示选择第 ii 后续选择的的尝试次数。而我们的问题就要找出 ii ,使得它对应的 YiY_i 最小,用坐标轴表示可能比较清晰:

在上一份的代码中,我们的做法是求出从 [1,N] 所有的 YiY_i的值,从中找出它们的最小值,即:

for (i in 1..N) {
    val y_i = ...
    y_k_n = Math.min(y_k_n, y_i)
}

这并没有错,只是效率并不是太高的。思考一个问题,给定两组数据,一组数据是从大到小有序排列的,一组数据大小是杂乱无章的,分别求出两个数组中的最小值。聪明的你一定想到有序的数据可以使用二分搜索对吧。

那么,我们这个问题是属于有序的数据还是杂乱无章的数据呢?是的,还真的是有序的数据。观察 YiY_i 的函数:

Yi=max(y1,y2)=max{dp(i1,Kc1),dp(Nci,Kc)}Y_i = max(y_1,y_2) = max\{dp(i - 1,K_c - 1),dp(N_c - i,K_c)\}

可以看到,YiY_i取决于dp(i1,Kc1)dp(i - 1,K_c - 1)dp(Nci,K)dp(N_c - i,K) 的值,取较大的那个。而NcN_cKcK_c都是常量,所以两者的最大值依旧是关于 ii的函数:

  • y1=dp(i1,Kc1)y_1 = dp(i - 1,K_c - 1):随着 ii 增大,是一个楼层增大的问题,函数值是单调递增的
  • y2=dp(Nci,K)y_2 = dp(N_c - i,K):随着 ii 增大,是一个楼层减少的问题,函数值是单调递减的

提示: 100层楼 2 个鸡蛋的尝试次数,不可能小于 99 层 2个鸡蛋的尝试次数,对吗。这里就不证明了,比较直观的结论。

用坐标轴表示可能比较清晰:

这不就是找出数据中的峰值问题吗?162. Find Peak Element 寻找峰值 【题解】

fun findPeakElement(nums: IntArray): Int {

    var left = 0
    var right = nums.size - 1

    while (left < right) {
        val mid = (left + right) ushr 1 // 左中位数
        if (nums[mid] < nums[mid + 1]) {
            // 如果 mid 严格小于右边一位的值,那么 mid 一定不是峰值,并且峰值在右侧
            left = mid + 1
        } else {
            right = mid
        }
    }
    return left
}

我们要做的其实就是找到 YiY_i 函数的谷底:即取区间的中间点 midmid,比较 brokenbrokennot_brokennot\_broken 两者的大小,如果 brokenbroken 严格小于 not_brokennot\_broken,说明 midmid 一定不是谷底,并且谷底在右侧,反之在左侧,参考代码如下 【题解】

class Solution {
    fun superEggDrop(K: Int, N: Int): Int {

        // K 行 N 列(鸡蛋的数目较少,作为行)
        val dp = Array(K + 1) {
            IntArray(N + 1) { -1 }
        }

        fun dp(K: Int, N: Int): Int {
            // 1、边界测试用例
            if (N <= 2) {
                // 边界1. 空楼/一层楼/两层楼的情况
                return N
            }
            if (K == 1) {
                // 边界2. 只有一个鸡蛋,只能线性搜索
                return N
            }
            if (K >= N) {
                // 边界3,鸡蛋“充足”,使用二分搜索
                return log2(N + 1) // 树的高度要能覆盖[0,N] 共 N + 1 个叶子节点
            }
            if (K == 0) {
                // 边界4,没有鸡蛋
                return 0
            }

            // 2、重叠子问题
            if (-1 != dp[K][N]) {
                return dp[K][N]
            }

            // 3、动态规划 + 二分搜索找谷底
            var left = 1
            var right = N
            var y_k_n = Integer.MAX_VALUE

            while (left < right) {
                val mid = (left + right) ushr 1 // 左中位数

                val broken = dp(K - 1, mid - 1) // 碎 -> [1,mid - 1]
                val no_broken = dp(K, N - mid) // 没碎 -> [mid - 1, N]

                if (broken < no_broken) { // 如果 broken 严格小于 no_broken,那么 mid 一定不是谷底,并且谷底在右侧
                    left = mid + 1
                    y_k_n = Math.min(y_k_n, no_broken)
                } else {
                    right = mid
                    y_k_n = Math.min(y_k_n, broken)
                }
            }
            // 加 1 是因为划分子问题时丢了 1 次
            return (y_k_n + 1).apply {
                dp[K][N] = this
            }
        }
        return dp(K, N)
    }

    // 以 2 为底的对数
    private fun log2(n: Int) = Math.ceil(Math.log(n.toDouble()) / Math.log(2.0)).toInt() // 向上取整
}

到这里,我们的动态规划解法就完成了,输出的 dp 数组里明显多了很多 -1 ,这说明改进后的程序跳过了很多无效的选择。

我们分析下算法复杂度:

  • 时间复杂度

由于很多无效的选择被剪枝了,所以子问题的个数一定是严格小于 NKNK 个;至于递归函数本身,使用二分查找的时间复杂度是O(lgn)O(lgn),综上,总的时间复杂度是O(KNlogN)O(KN*logN),这只是一个不太紧的上界。

  • 空间复杂度 使用了二维数组,空间复杂度是 O(KN)O(KN)

《LeetCode 官方的题解》中,还提出了时间复杂度为O(KN)O(K∗N)的解法,不在我的能力范围内,有兴趣可以一起讨论。


本文正在参与「掘金 2021 春招闯关活动」, 点击查看 活动详情


参考资料

推荐阅读

数据结构与算法系列完整目录如下(2023/07/11 更新):

Java & Android 集合框架系列文章: 跳转阅读

LeetCode 上分之旅系列文章:跳转阅读

⭐️ 永远相信美好的事情即将发生,欢迎加入小彭的 Android 交流社群~