Welcome to Subscribe On Youtube
2136. Earliest Possible Day of Full Bloom
Description
You have n
flower seeds. Every seed must be planted first before it can begin to grow, then bloom. Planting a seed takes time and so does the growth of a seed. You are given two 0indexed integer arrays plantTime
and growTime
, of length n
each:
plantTime[i]
is the number of full days it takes you to plant thei^{th}
seed. Every day, you can work on planting exactly one seed. You do not have to work on planting the same seed on consecutive days, but the planting of a seed is not complete until you have workedplantTime[i]
days on planting it in total.growTime[i]
is the number of full days it takes thei^{th}
seed to grow after being completely planted. After the last day of its growth, the flower blooms and stays bloomed forever.
From the beginning of day 0
, you can plant the seeds in any order.
Return the earliest possible day where all seeds are blooming.
Example 1:
Input: plantTime = [1,4,3], growTime = [2,3,1] Output: 9 Explanation: The grayed out pots represent planting days, colored pots represent growing days, and the flower represents the day it blooms. One optimal way is: On day 0, plant the 0^{th} seed. The seed grows for 2 full days and blooms on day 3. On days 1, 2, 3, and 4, plant the 1^{st} seed. The seed grows for 3 full days and blooms on day 8. On days 5, 6, and 7, plant the 2^{nd} seed. The seed grows for 1 full day and blooms on day 9. Thus, on day 9, all the seeds are blooming.
Example 2:
Input: plantTime = [1,2,3,2], growTime = [2,1,2,1] Output: 9 Explanation: The grayed out pots represent planting days, colored pots represent growing days, and the flower represents the day it blooms. One optimal way is: On day 1, plant the 0^{th} seed. The seed grows for 2 full days and blooms on day 4. On days 0 and 3, plant the 1^{st} seed. The seed grows for 1 full day and blooms on day 5. On days 2, 4, and 5, plant the 2^{nd} seed. The seed grows for 2 full days and blooms on day 8. On days 6 and 7, plant the 3^{rd} seed. The seed grows for 1 full day and blooms on day 9. Thus, on day 9, all the seeds are blooming.
Example 3:
Input: plantTime = [1], growTime = [1] Output: 2 Explanation: On day 0, plant the 0^{th} seed. The seed grows for 1 full day and blooms on day 2. Thus, on day 2, all the seeds are blooming.
Constraints:
n == plantTime.length == growTime.length
1 <= n <= 10^{5}
1 <= plantTime[i], growTime[i] <= 10^{4}
Solutions

class Solution { public int earliestFullBloom(int[] plantTime, int[] growTime) { int n = plantTime.length; Integer[] idx = new Integer[n]; for (int i = 0; i < n; i++) { idx[i] = i; } Arrays.sort(idx, (i, j) > growTime[j]  growTime[i]); int ans = 0, t = 0; for (int i : idx) { t += plantTime[i]; ans = Math.max(ans, t + growTime[i]); } return ans; } }

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

class Solution: def earliestFullBloom(self, plantTime: List[int], growTime: List[int]) > int: ans = t = 0 for pt, gt in sorted(zip(plantTime, growTime), key=lambda x: x[1]): t += pt ans = max(ans, t + gt) return ans

func earliestFullBloom(plantTime []int, growTime []int) (ans int) { n := len(plantTime) idx := make([]int, n) for i := range idx { idx[i] = i } sort.Slice(idx, func(i, j int) bool { return growTime[idx[j]] < growTime[idx[i]] }) t := 0 for _, i := range idx { t += plantTime[i] ans = max(ans, t+growTime[i]) } return }

function earliestFullBloom(plantTime: number[], growTime: number[]): number { const n = plantTime.length; const idx: number[] = Array.from({ length: n }, (_, i) => i); idx.sort((i, j) => growTime[j]  growTime[i]); let [ans, t] = [0, 0]; for (const i of idx) { t += plantTime[i]; ans = Math.max(ans, t + growTime[i]); } return ans; }

impl Solution { pub fn earliest_full_bloom(plant_time: Vec<i32>, grow_time: Vec<i32>) > i32 { let mut idx: Vec<usize> = (0..plant_time.len()).collect(); idx.sort_by_key(&i &grow_time[i]); let mut ans = 0; let mut t = 0; for &i in &idx { t += plant_time[i]; ans = ans.max(t + grow_time[i]); } ans } }