剖析 LeetCode 808. 分汤：巧用动态规划分门别类

2024-01-19 07:50:27

序言

在 LeetCode 题库中，808. 分汤算得上是一道中等偏上的题目，它融合了数学、动态规划和线性 DP 等元素，考察了应聘者的综合解题能力。这篇文章将带领读者深入剖析这道题目，从题目到解决思路，再到代码实现，帮助读者逐步掌握解决此类问题的技巧。

题目

两位朋友 Alice 和 Bob 正在分享两碗汤，A 类和 B 类。一开始，每种类型的汤都有 n 毫升。有四种分配汤的方式：

Alice 喝 A 汤，Bob 喝 B 汤。
Alice 喝 B 汤，Bob 喝 A 汤。
Alice 喝 A 汤和 B 汤。
Bob 喝 A 汤和 B 汤。

他们轮流喝汤，直到没有汤喝为止。Alice 和 Bob 都希望喝到尽可能多的汤。

解决思路

这道题目的本质是求出 Alice 和 Bob 在最优情况下能喝到多少汤。为了解决这个问题，我们可以使用动态规划算法。

我们定义一个二维数组 dp，其中 dp[i][j] 表示 Alice 和 Bob 在还剩 i 毫升 A 类汤和 j 毫升 B 类汤时，他们能喝到的最大汤量。

初始状态：

dp[0][0] = 0
dp[i][0] = i
dp[0][j] = j

转移方程：

对于每个状态 dp[i][j]，我们有四种转移方式：

Alice 喝 A 汤：dp[i][j] = max(dp[i][j], dp[i-1][j] + 1)
Alice 喝 B 汤：dp[i][j] = max(dp[i][j], dp[i][j-1] + 1)
Alice 喝 A 汤和 B 汤：dp[i][j] = max(dp[i][j], dp[i-1][j-1] + 2)
Bob 喝 A 汤和 B 汤：dp[i][j] = max(dp[i][j], dp[i-1][j-1] + 2)

最终结果：

dp[n][n] 表示 Alice 和 Bob 在最优情况下能喝到的最大汤量。

代码实现

def max_汤(a: int, b: int) -> int:
    """
    返回 Alice 和 Bob 在最优情况下能喝到的最大汤量。

    Args:
    a: A 类汤的初始容量。
    b: B 类汤的初始容量。

    Returns:
    Alice 和 Bob 在最优情况下能喝到的最大汤量。
    """

    # 创建一个二维数组 dp 来存储子问题的结果。
    dp = [[0 for _ in range(b + 1)] for _ in range(a + 1)]

    # 初始化边界条件。
    for i in range(1, a + 1):
        dp[i][0] = i
    for j in range(1, b + 1):
        dp[0][j] = j

    # 填写表格。
    for i in range(1, a + 1):
        for j in range(1, b + 1):
            dp[i][j] = max(dp[i-1][j], dp[i][j-1], dp[i-1][j-1] + 2)

    # 返回最终结果。
    return dp[a][b]


if __name__ == "__main__":
    # 测试用例。
    test_cases = [
        (2, 3),
        (4, 5),
        (10, 15),
    ]

    for a, b in test_cases:
        result = max_汤(a, b)
        print(f"A 类汤的初始容量：{a}, B 类汤的初始容量：{b}, 最大汤量：{result}")