2136. Earliest Possible Day of Full Bloom LeetCode Solution

Last updated: February 26, 2025

In this guide, you will get 2136. Earliest Possible Day of Full Bloom LeetCode Solution with the best time and space complexity. The solution to Earliest Possible Day of Full Bloom problem is provided in various programming languages like C++, Java, and Python. This will be helpful for you if you are preparing for placements, hackathons, interviews, or practice purposes. The solutions provided here are very easy to follow and include detailed explanations.

Problem Statement
Complexity Analysis
Earliest Possible Day of Full Bloom solution in C++
Earliest Possible Day of Full Bloom solution in Java
Earliest Possible Day of Full Bloom solution in Python
Additional Resources

2136. Earliest Possible Day of Full Bloom LeetCode Solution image

Problem Statement of Earliest Possible Day of Full Bloom

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 0-indexed integer arrays plantTime and growTime, of length n each:

plantTime[i] is the number of full days it takes you to plant the ith 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 worked plantTime[i] days on planting it in total.
growTime[i] is the number of full days it takes the ith 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 0th seed. The seed grows for 2 full days and blooms on day 3.
On days 1, 2, 3, and 4, plant the 1st seed. The seed grows for 3 full days and blooms on day 8.
On days 5, 6, and 7, plant the 2nd 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 0th seed. The seed grows for 2 full days and blooms on day 4.
On days 0 and 3, plant the 1st seed. The seed grows for 1 full day and blooms on day 5.
On days 2, 4, and 5, plant the 2nd seed. The seed grows for 2 full days and blooms on day 8.
On days 6 and 7, plant the 3rd 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 0th 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 <= 105
1 <= plantTime[i], growTime[i] <= 104

Complexity Analysis

Time Complexity: O(\texttt{sort})
Space Complexity: O(n)

2136. Earliest Possible Day of Full Bloom LeetCode Solution in C++

struct Seed {
  int p;
  int g;
};

class Solution {
 public:
  int earliestFullBloom(vector<int>& plantTime, vector<int>& growTime) {
    int ans = 0;
    int time = 0;
    vector<Seed> seeds;

    for (int i = 0; i < plantTime.size(); ++i)
      seeds.emplace_back(plantTime[i], growTime[i]);

    ranges::sort(seeds, ranges::greater{},
                 [](const Seed& seed) { return seed.g; });

    for (const auto& [p, g] : seeds) {
      time += p;
      ans = max(ans, time + g);
    }

    return ans;
  }
};
/* code provided by PROGIEZ */

2136. Earliest Possible Day of Full Bloom LeetCode Solution in Java

class Solution {
  public int earliestFullBloom(int[] plantTime, int[] growTime) {
    record Seed(int p, int g) {}
    final int n = plantTime.length;
    int ans = 0;
    int time = 0;
    Seed[] seeds = new Seed[n];

    for (int i = 0; i < plantTime.length; ++i)
      seeds[i] = new Seed(plantTime[i], growTime[i]);

    Arrays.sort(seeds, (a, b) -> Integer.compare(b.g, a.g));

    for (Seed seed : seeds) {
      time += seed.p;
      ans = Math.max(ans, time + seed.g);
    }

    return ans;
  }
}
// code provided by PROGIEZ

2136. Earliest Possible Day of Full Bloom LeetCode Solution in Python

class Solution:
  def earliestFullBloom(self, plantTime: list[int], growTime: list[int]) -> int:
    ans = 0
    time = 0

    for p, g in sorted(
        [(p, g) for (p, g) in zip(plantTime, growTime)],
            key=lambda x: -x[1]):
      time += p
      ans = max(ans, time + g)

    return ans
 # code by PROGIEZ

Additional Resources

Happy Coding! Keep following PROGIEZ for more updates and solutions.

Table of Contents