【动态规划】高楼扔鸡蛋问题

合集 - 动态规划(15)

1.【动态规划】最长公共子序列2022-11-152.【动态规划】最长递增子序列2022-11-193.【动态规划】子串、子序列问题2023-07-064.【动态规划】股票买卖问题2023-01-115.【动态规划】背包问题的应用2023-01-096.【动态规划】背包问题2023-01-037.【动态规划】矩阵2023-02-288.【动态规划】压缩状态2023-02-27

9.【动态规划】高楼扔鸡蛋问题2023-01-17

10.【动态规划】打家劫舍2023-01-1611.【动态规划】博弈问题2023-01-1212.【动态规划】编辑距离2022-12-2613.【动态规划】正则表达式2024-01-2214.【动态规划】矩阵2024-01-2415.【动态规划】最长公共子串2024-02-05

收起

目录

• 高楼扔鸡蛋
  • 题目
• 方法一：动态规划
  • 分析
    • 边界条件
    • 状态转移
  • 代码实现
  • 复杂度
• 方法二：动态规划 + 二分搜索
  • 分析
  • 代码实现
  • 复杂度

高楼扔鸡蛋

这是一个比较经典的动态规划问题，最先来自谷歌的面试题。

题目

887. 鸡蛋掉落

方法一：动态规划

分析

我们假设 $g(k,n)$ 表示当有 $k$ 枚鸡蛋，楼层数为 $n$ 时，找到临界楼层 $F$ 所需要的最小操作次数。

边界条件

当楼层数为零时，查找次数为 $0$ ，当鸡蛋数量为 $1$ 时，我们需要一层一层地查找，因此，最坏的情况下，查找次数等于楼层数，因此：

$$\begin{array}{c}g(j,0)=0,0\le j\le k\\ g(1,i)=i,1\le i\le n\end{array}$$

状态转移

我们考虑一般情况，对于第 $i$ 层楼：

$$\underbrace{1,2,\cdots ,i-1},i,\underbrace{i+1,\cdots ,n-1,n}$$

当我们从第 $i$ 层楼扔下一枚鸡蛋的时候，这枚鸡蛋有两种状态，鸡蛋碎了或者不碎，那么：

• 若鸡蛋没有碎

  我们可以继续用 $k$ 枚鸡蛋，在上方的楼层，即 $i+1,\cdots ,n$，共 $n-i$ 层楼中，继续寻找 $F$，因此，所需要查找的次数为 $g_1=g(k,n-i)$ ；

• 若鸡蛋碎了

  这时，鸡蛋的数量少了一枚，因此，我们就需要用剩余的 $k-1$ 枚鸡蛋，在下方的楼层，即 $1,\cdots ,i-1$，共 $i-1$ 层楼中，继续寻找 $F$，因此所需要查找的次数为 $g_2=g(k-1,i-1)$ 。

这里，我们可以看到，通过状态转移，明显将问题的规模缩小了，由于题目是要求在最坏的情况下，扔鸡蛋的最少次数，所以，最坏的情况下，在第 $i$ 层楼的操作次数，取决于 $g_1$ 和 $g_2$ 的最大值。

因此，在最坏的情况下，最少的操作次数为：

$$g(k,n)=\underset{i=1}{\overset{n}{min}}(max(g_1,g_2))+1=\underset{i=1}{\overset{n}{min}}(max(g(k,n-i),g(k-1,i-1)))+1$$

代码实现

• 自顶向下的递归实现

class Solution:
    def superEggDrop(self, k: int, n: int) -> int:
        memory = dict()
        return self.drop_egg(k, n, memory)
 
    def drop_egg(self, k: int, n: int, memory) -> int:
        if n == 0:
            return 0
 
        if k == 1:
            return n
 
        if (k, n) in memory:
            return memory.get((k, n))
 
        result = float("INF")
        for i in range(1, n + 1):
            g1 = self.drop_egg(k, n - i, memory)
            g2 = self.drop_egg(k - 1, i - 1, memory)
            result = min(result, max(g1, g2) + 1)
 
        memory[(k, n)] = result
        return result

• 自底向上的迭代实现

class Solution:
    def superEggDrop(self, k: int, n: int) -> int:
        return self.drop_egg(k, n)
 
    def drop_egg(self, eggs: int, floor: int) -> int:
        dp = [[float("INF") for _ in range(floor + 1)] for _ in range(eggs + 1)]
 
        # 鸡蛋数为1时
        for n in range(1, floor + 1):
            dp[1][n] = n
 
        # 楼层数为0
        for i in range(0, eggs + 1):
            dp[i][0] = 0
 
        # 楼层数为1
        dp[0][1] = 0
        for i in range(1, eggs + 1):
            dp[i][1] = 1
 
        for k in range(2, eggs + 1):
            for n in range(2, floor + 1):
                for i in range(1, n + 1):
                    g1 = dp[k][n - i]
                    g2 = dp[k - 1][i - 1]
                    dp[k][n] = min(dp[k][n], max(g1, g2) + 1)
 
        return int(dp[eggs][floor])

复杂度

复杂度分析：

• 时间复杂度：$O(k\times n^2)$；
• 空间复杂度：$O(k\times n)$。

注：这种方法，直接枚举所有的状态，在力扣上提交的时候，会超时，因此，我们还需要对上述算法做进一步优化。

方法二：动态规划 + 二分搜索

分析

这里，我们定义一个函数 $f(k,i)$，令

$$f(k,i)=\underset{i=1}{\overset{n}{max}}(g_1,g_2)=\underset{i=1}{\overset{n}{max}}(g(k,n-i),g(k-1,i-1))$$

结合前面的分析，我们可以看出，当 $k$ 不变时，即鸡蛋的个数不变时，函数 $g_1$ 和 函数 $g_2$ 只受楼层高度 $i$ 影响，即：

• $g_1=g(k,n-i),1\in [i,n]$ 是一个随 $i$ 增加的单调递减函数；
• $g_2=g(k-1,i-1),1\in [i,n]$ 是一个随 $i$ 增加的单调递增函数；

对于函数 $g_1$ 和 函数 $g_2$ 在区间 $[i,n]$ 内，因为变量 $i$ 只能取区间 $[i,n]$ 内离散的整数，因此，在区间 $[i,n]$ 内必然存在一个点 $(k_0,i_0)$ 使得单调函数 $g_1$ 和单调函数 $g_2$ 的值相等，这里，我们假设函数$f(k,i)$的最小值是 $f(k_0,n_0)$。

因此，我们可以将函数 $f(k,i)$表示为：

$$f(k,i)=\{\begin{array}{ll}g(k,n-i),& 1\le i\le i_0\\ g(k-1,i-1),& i_0\le i\le n\end{array}$$

那么，状态转移方程，就可以写成：

$$g(k,n)=\underset{i=1}{\overset{n}{min}}(f(k,i))=f(k_0,n_0)$$

那么，我们只需要将优化的重点，放在求解 $f(k_0,n_0)$ 上即可。对于单调函数，在区间 $[i,n]$ 内我们可以通过二分法的方式缩小查找区间，求解 $f(k_0,n_0)$。

注意：

• 函数 $g_1$ 和 函数 $g_2$ 并非严格递增或者递减；
• 我们可以通过数学方式证明，使得函数 $g_1$ 和 函数 $g_2$ 在区间 $[i,n]$ 相等的点有两个，分别为 $(k_0,i_0)$ 和 $(k_1,i_1)$，且 $i_0$ 和 $i_1$ 相差 $1$，我们并不需要关心具体值是多少，我们只需要记录它们所对应的函数值即可。

代码实现

• 自顶向下的递归实现

from typing import Dict
 
class Solution:
    def superEggDrop(self, k: int, n: int) -> int:
        memory = dict()
        return self.drop_egg(k, n, memory)
 
    def drop_egg(self, k: int, n: int, memory: Dict) -> int:
        if n == 0:
            return 0
 
        if k == 1:
            return n
 
        if (k, n) in memory:
            return memory.get((k, n))
 
        result = float("INF")
        left, right = 1, n
        while left <= right:
            mid = left + (right - left) // 2
            g1 = self.drop_egg(k, n - mid, memory)
            g2 = self.drop_egg(k - 1, mid - 1, memory)
            result = min(result, max(g1, g2) + 1)
            if g1 < g2:
                right = mid - 1
            elif g1 > g2:
                left = mid + 1
            else:
                break
 
        memory[(k, n)] = result
        return result

• 自底向上的迭代实现

class Solution:
    def superEggDrop(self, k: int, n: int) -> int:
        return self.drop_egg(k, n)
 
    def drop_egg(self, eggs: int, floor: int) -> int:
        dp = [[float("INF") for _ in range(floor + 1)] for _ in range(eggs + 1)]
 
        # 鸡蛋数为1时
        for n in range(1, floor + 1):
            dp[1][n] = n
 
        # 楼层数为0
        for i in range(0, eggs + 1):
            dp[i][0] = 0
 
        # 楼层数为1
        dp[0][1] = 0
        for i in range(1, eggs + 1):
            dp[i][1] = 1
 
        for k in range(2, eggs + 1):
            for n in range(2, floor + 1):
                # 使用二分搜索代替迭代搜索
                result = float("INF")
                left, right = 1, n
                while left <= right:
                    mid = left + (right - left) // 2
                    g1 = dp[k][n - mid]
                    g2 = dp[k - 1][mid - 1]
                    result = min(result, max(g1, g2) + 1)
                    if g1 < g2:
                        right = mid - 1
                    elif g1 > g2:
                        left = mid + 1
                    else:
                        break
 
                dp[k][n] = result
 
        return int(dp[eggs][floor])

复杂度

复杂度分析：

• 时间复杂度：$O(k\times n\times logn)$；
• 空间复杂度：$O(k\times n)$。

---