全部开花的最早一天

2136. 全部开花的最早一天

你有 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⁴

原站题解

去查看

上次编辑到这里，代码来自缓存点击恢复默认模板

class Solution { public: int earliestFullBloom(vector<int>& plantTime, vector<int>& growTime) { } };

cpp 解法, 执行用时: 348 ms, 内存消耗: 152 MB, 提交时间: 2023-09-30 10:38:47

class Solution {
public:
    int earliestFullBloom(vector<int>& plantTime, vector<int>& growTime) {
        int n = plantTime.size();
        vector<int> id(n);  
        iota(id.begin(), id.end(), 0);
        sort(id.begin(), id.end(), [&](int i, int j) {
            return growTime[i] > growTime[j];
        });
        int prev = 0, ans = 0;
        for (int i: id) {
            ans = max(ans, prev + plantTime[i] + growTime[i]);
            prev += plantTime[i];
        }
        return ans;
    }
};

golang 解法, 执行用时: 204 ms, 内存消耗: 10.3 MB, 提交时间: 2023-05-16 11:21:08

func earliestFullBloom(plantTime, growTime []int) (ans int) {
	type pair struct{ p, g int }
	a := make([]pair, len(plantTime))
	for i, p := range plantTime {
		a[i] = pair{p, growTime[i]}
	}
	sort.Slice(a, func(i, j int) bool { return a[i].g > a[j].g })
	day := 0
	for _, p := range a {
		day += p.p
		if day+p.g > ans {
			ans = day + p.g
		}
	}
	return
}

java 解法, 执行用时: 55 ms, 内存消耗: 58.1 MB, 提交时间: 2023-05-16 11:20:52

class Solution {
    public int earliestFullBloom(int[] plantTime, int[] growTime) {
        var id = IntStream.range(0, plantTime.length).boxed().toArray(Integer[]::new);
        Arrays.sort(id, (i, j) -> growTime[j] - growTime[i]);
        var ans = 0;
        var day = 0;
        for (var i : id) {
            day += plantTime[i];
            ans = Math.max(ans, day + growTime[i]);
        }
        return ans;
    }
}

python3 解法, 执行用时: 324 ms, 内存消耗: 38.2 MB, 提交时间: 2023-05-16 11:20:39

# 按照生长天数从大到小排序后，交换任意两枚种子的播种顺序，不会让最晚开花时间提前。
class Solution:
    def earliestFullBloom(self, plantTime: List[int], growTime: List[int]) -> int:
        ans = day = 0
        for plant, grow in sorted(zip(plantTime, growTime), key=lambda x: -x[1]):
            day += plant
            ans = max(ans, day + grow)
        return ans

上一题

下一题

详情