全部开花的最早一天

难度: Hard

你有 n 枚花的种子。每枚种子必须先种下，才能开始生长、开花。播种需要时间，种子的生长也是如此。给你两个下标从 0 开始的整数数组 plantTime 和 growTime ，每个数组的长度都是 n ：

plantTime[i] 是播种第 i 枚种子所需的 完整天数 。每天，你只能为播种某一枚种子而劳作。无须连续几天都在种同一枚种子，但是种子播种必须在你工作的天数达到 plantTime[i] 之后才算完成。
growTime[i] 是第 i 枚种子完全种下后生长所需的 完整天数 。在它生长的最后一天之后，将会开花并且永远绽放。

从第 0 开始，你可以按任意顺序播种种子。

返回所有种子都开花的最早一天是第几天。

示例 1：

输入：plantTime = [1,4,3], growTime = [2,3,1]
输出：9
解释：灰色的花盆表示播种的日子，彩色的花盆表示生长的日子，花朵表示开花的日子。
一种最优方案是：
第 0 天，播种第 0 枚种子，种子生长 2 整天。并在第 3 天开花。
第 1、2、3、4 天，播种第 1 枚种子。种子生长 3 整天，并在第 8 天开花。
第 5、6、7 天，播种第 2 枚种子。种子生长 1 整天，并在第 9 天开花。
因此，在第 9 天，所有种子都开花。

示例 2：

输入：plantTime = [1,2,3,2], growTime = [2,1,2,1]
输出：9
解释：灰色的花盆表示播种的日子，彩色的花盆表示生长的日子，花朵表示开花的日子。 
一种最优方案是：
第 1 天，播种第 0 枚种子，种子生长 2 整天。并在第 4 天开花。
第 0、3 天，播种第 1 枚种子。种子生长 1 整天，并在第 5 天开花。
第 2、4、5 天，播种第 2 枚种子。种子生长 2 整天，并在第 8 天开花。
第 6、7 天，播种第 3 枚种子。种子生长 1 整天，并在第 9 天开花。
因此，在第 9 天，所有种子都开花。

示例 3：

输入：plantTime = [1], growTime = [1]
输出：2
解释：第 0 天，播种第 0 枚种子。种子需要生长 1 整天，然后在第 2 天开花。
因此，在第 2 天，所有种子都开花。

提示：

n == plantTime.length == growTime.length
1 <= n <= 10⁵
1 <= plantTime[i], growTime[i] <= 10⁴

Submission

运行时间: 189 ms

内存: 31.2 MB

from typing import List, Tuple


class Solution:
    def earliestFullBloom(self, plantTime: List[int], growTime: List[int]) -> int:
        n = len(plantTime)
        order = list(range(n))
        order.sort(key=lambda x: growTime[x], reverse=True)
        serial, res = 0, 0
        for i in order:
            cpu, io = plantTime[i], growTime[i]
            serial += cpu
            res = max(res, serial + io)
        return res

Explain

此题的关键是确定种子的播种顺序，以使得所有种子尽可能早地开花。考虑到种子的生长时间对总开花时间的影响较大，特别是对于生长时间长的种子，如果将它们放在后面播种，它们的开花时间将极大地延后。因此，一个有效的策略是优先播种生长时间长的种子。具体步骤如下：\n1. 将所有种子按照生长时间从大到小排序。\n2. 按排序后的顺序依次播种每一枚种子，并计算每枚种子的开花时间。\n3. 开花时间是播种完成后紧接着的生长时间，总的开花时间为所有种子中最晚的一个开花时间。

时间复杂度: O(n log n)

空间复杂度: O(n)

from typing import List


class Solution:
    def earliestFullBloom(self, plantTime: List[int], growTime: List[int]) -> int:
        n = len(plantTime)  # 获取种子的总数
        order = list(range(n))  # 创建种子的索引列表
        # 根据生长时间对种子进行降序排序
        order.sort(key=lambda x: growTime[x], reverse=True)
        serial, res = 0, 0  # 初始化播种天数和最终结果
        for i in order:  # 遍历排序后的种子索引
            cpu, io = plantTime[i], growTime[i]  # cpu为播种时间，io为生长时间
            serial += cpu  # 更新播种完成的总天数
            res = max(res, serial + io)  # 计算当前种子开花的时间，并更新最终结果
        return res  # 返回所有种子都开花的最早一天

Explore

在解决这个问题时，我们需要计算所有种子都开花的最早一天。每个种子的开花时间取决于其播种完成的时间（`serial`）加上其生长时间（`io`）。由于种子是依次播种的，每种一个种子后，`serial`会累加该种子的播种时间。对于每个种子，其开花的具体时间是`serial + io`。由于我们需要所有种子都开花的最早一天，因此我们需要在所有种子中找到开花时间最晚的那一天，这就是为什么使用`max(res, serial + io)`来更新结果。这样可以确保`res`始终是目前为止计算出的所有种子中开花最晚的一天。

`serial`代表到当前种子为止，总共花费的播种时间。每播种一个种子，我们就将该种子的播种时间加到`serial`上。`res`代表计算到目前为止，所有种子都已经开花的最早一天。在每次播种一个新的种子后，我们计算该种子的开花时间（`serial + io`），并用这个时间来更新`res`，确保`res`始终保持为所有种子中最晚的一个开花时间。这样，`serial`和`res`共同作用于结果计算，其中`serial`负责记录播种时间累计，而`res`负责记录所有种子开花的最晚时间。