Earliest Possible Day of Full Bloom - Problem

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 i-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 worked plantTime[i] days on planting it in total.
growTime[i] is the number of full days it takes the i-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.

Input & Output

Example 1 — Basic Case

$ Input: plantTime = [1,4,3], growTime = [2,3,1]

› Output: 9

💡 Note: Optimal order is to plant seed 1 (grow time 3), then seed 0 (grow time 2), then seed 2 (grow time 1). Plant seed 1 on days 0-3 (completes day 4), blooms day 7. Plant seed 0 on day 4 (completes day 5), blooms day 7. Plant seed 2 on days 5-7 (completes day 8), blooms day 9. All seeds bloom by day 9.

Example 2 — Equal Plant Times

$ Input: plantTime = [1,2,3,2], growTime = [2,1,2,1]

› Output: 9

💡 Note: Sort by grow time descending: seeds 0,2 (grow=2), then seeds 1,3 (grow=1). Plant in order [0,2,1,3]. Seed 0: plant days 0, blooms day 1+2=3. Seed 2: plant days 1-3, blooms day 4+2=6. Seed 1: plant days 4-5, blooms day 6+1=7. Seed 3: plant days 6-7, blooms day 8+1=9.

Example 3 — Single Seed

$ Input: plantTime = [1], growTime = [1]

› Output: 2

💡 Note: Only one seed: plant it on day 0, completes day 1, blooms on day 1+1=2.

Constraints

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

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8 f Meta 6

The key insight is that we should plant seeds with longer grow times first to minimize the overall completion time. The optimal approach sorts seeds by grow time in descending order and plants them sequentially. Time: O(n log n), Space: O(n).

Common Approaches

✓ Greedy: Sort by Grow Time

⏱️ Time: O(n log n) Space: O(n)

The key insight is to plant seeds with longer grow times first. This minimizes the overall completion time because while we're planting other seeds, the long-growing ones are already growing in parallel.

Try All Permutations

⏱️ Time: O(n! × n) Space: O(n)

Generate all n! permutations of seed planting orders. For each permutation, calculate when all seeds will bloom by tracking planting completion times and adding grow times. Return the minimum across all permutations.

Greedy: Sort by Grow Time — Algorithm Steps

Pair each seed with its index
Sort by grow time in descending order
Plant seeds in sorted order and calculate final bloom day

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Seeds

Sort by grow time descending

Plant in Order

Plant seeds with longest grow times first

Calculate Bloom

Track when each seed blooms and find maximum

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int grow;
    int plant;
} Seed;

int compare(const void* a, const void* b) {
    Seed* seedA = (Seed*)a;
    Seed* seedB = (Seed*)b;
    return seedB->grow - seedA->grow; // Descending order
}

int solution(int* plantTime, int* growTime, int n) {
    Seed* seeds = malloc(n * sizeof(Seed));
    
    for (int i = 0; i < n; i++) {
        seeds[i].grow = growTime[i];
        seeds[i].plant = plantTime[i];
    }
    
    qsort(seeds, n, sizeof(Seed), compare);
    
    int currentPlantDay = 0;
    int maxBloomDay = 0;
    
    for (int i = 0; i < n; i++) {
        currentPlantDay += seeds[i].plant;
        int bloomDay = currentPlantDay + seeds[i].grow;
        if (bloomDay > maxBloomDay) {
            maxBloomDay = bloomDay;
        }
    }
    
    free(seeds);
    return maxBloomDay;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int plantTime[1000], growTime[1000];
    int n = 0;
    
    char* token = strtok(line, "[,]");
    while (token != NULL && n < 1000) {
        plantTime[n++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    fgets(line, sizeof(line), stdin);
    int m = 0;
    token = strtok(line, "[,]");
    while (token != NULL && m < 1000) {
        growTime[m++] = atoi(token);
        token = strtok(NULL, "[,]");
    }
    
    printf("%d\n", solution(plantTime, growTime, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting the seeds by grow time dominates the complexity

⚡ Linearithmic

Space Complexity

O(n)

Storage for seed pairs and sorting space

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 min Avg. Time

845 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Earliest Possible Day of Full Bloom - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Greedy: Sort by Grow Time — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler