Number of Flowers in Full Bloom - Problem

Array Hash Table Binary Search Sorting Prefix Sum Ordered Set Hard

You are given a 0-indexed 2D integer array flowers, where flowers[i] = [start_i, end_i] means the i^th flower will be in full bloom from start_i to end_i (inclusive).

You are also given a 0-indexed integer array people of size n, where people[i] is the time that the i^th person will arrive to see the flowers.

Return an integer array answer of size n, where answer[i] is the number of flowers that are in full bloom when the i^th person arrives.

Input & Output

Example 1 — Basic Case

$ Input: flowers = [[1,6],[3,7],[9,12]], people = [2,3,7,11]

› Output: [1,2,2,1]

💡 Note: At time 2: flower [1,6] is blooming (1). At time 3: flowers [1,6] and [3,7] are blooming (2). At time 7: flowers [1,6] and [3,7] are blooming (2). At time 11: flower [9,12] is blooming (1).

Example 2 — No Overlap

$ Input: flowers = [[1,10],[3,3]], people = [3,3,2]

› Output: [2,2,1]

💡 Note: At time 3: both flowers [1,10] and [3,3] are blooming (2). At time 2: only flower [1,10] is blooming (1).

Example 3 — Edge Case

$ Input: flowers = [[1,1]], people = [1,2]

› Output: [1,0]

💡 Note: At time 1: flower [1,1] is blooming (1). At time 2: no flowers are blooming (0).

Constraints

1 ≤ flowers.length ≤ 5 × 10⁴
flowers[i].length == 2
1 ≤ start_i ≤ end_i ≤ 10⁹
1 ≤ people.length ≤ 5 × 10⁴
1 ≤ people[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 25 a Amazon 18 f Facebook 15 M Microsoft 12

The key insight is to separate flower bloom events into start and end times, then use binary search for efficient querying. Instead of checking every flower for each person (O(n×m)), we sort start/end times once and binary search for each query. Best approach uses Binary Search on Events with Time: O((n+m) log m), Space: O(m).

Common Approaches

✓ Binary Search on Events

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

Create sorted arrays of start times and end times. For each person, use binary search to count how many flowers have started minus how many have ended.

Brute Force - Check Each Flower

⏱️ Time: O(n×m) Space: O(1)

For each person's arrival time, check every flower to see if it's blooming during that time period. A flower blooms if start ≤ person_time ≤ end.

Binary Search on Events — Algorithm Steps

Extract and sort start times
Extract and sort end times
For each person, binary search both arrays
Count = starts_before_or_at - ends_before

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Events

Create sorted arrays of starts and ends

Binary Search

Find position in each sorted array

Calculate Count

started_count - ended_count = blooming

Code -

solution.c — C

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

int compare(const void* a, const void* b) {
    return (*(int*)a - *(int*)b);
}

int bisect_right(int* arr, int size, int target) {
    int left = 0, right = size;
    while (left < right) {
        int mid = (left + right) / 2;
        if (arr[mid] <= target) left = mid + 1;
        else right = mid;
    }
    return left;
}

int bisect_left(int* arr, int size, int target) {
    int left = 0, right = size;
    while (left < right) {
        int mid = (left + right) / 2;
        if (arr[mid] < target) left = mid + 1;
        else right = mid;
    }
    return left;
}

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);
    }
}

void parse2DArray(const char* str, int flowers[][2], int* flowersSize) {
    *flowersSize = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        
        if (*p == '[') {
            p++;
            flowers[*flowersSize][0] = (int)strtol(p, (char**)&p, 10);
            while (*p == ' ' || *p == ',') p++;
            flowers[*flowersSize][1] = (int)strtol(p, (char**)&p, 10);
            while (*p && *p != ']') p++;
            if (*p == ']') p++;
            (*flowersSize)++;
        } else {
            p++;
        }
    }
}

int* solution(int flowers[][2], int flowersSize, int* people, int peopleSize, int* returnSize) {
    int* starts = (int*)malloc(flowersSize * sizeof(int));
    int* ends = (int*)malloc(flowersSize * sizeof(int));
    
    for (int i = 0; i < flowersSize; i++) {
        starts[i] = flowers[i][0];
        ends[i] = flowers[i][1];
    }
    
    qsort(starts, flowersSize, sizeof(int), compare);
    qsort(ends, flowersSize, sizeof(int), compare);
    
    int* result = (int*)malloc(peopleSize * sizeof(int));
    *returnSize = peopleSize;
    
    for (int i = 0; i < peopleSize; i++) {
        int started = bisect_right(starts, flowersSize, people[i]);
        int ended = bisect_left(ends, flowersSize, people[i]);
        result[i] = started - ended;
    }
    
    free(starts);
    free(ends);
    return result;
}

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int flowers[1000][2];
    int people[1000];
    int flowersSize, peopleSize;
    
    parse2DArray(line1, flowers, &flowersSize);
    parseArray(line2, people, &peopleSize);
    
    int returnSize;
    int* result = solution(flowers, flowersSize, people, peopleSize, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O((n+m) log m)

Sorting takes O(m log m), then for each of n people we do 2 binary searches O(log m)

✓ Linear Growth

Space Complexity

O(m)

Store sorted arrays of start and end times, each of size m

✓ Linear Space

89.3K Views

Medium Frequency

~25 min Avg. Time

1.8K 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

Number of Flowers in Full Bloom - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Binary Search on Events — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler