Minimum Number of Days to Make m Bouquets

Minimum Number of Days to Make m Bouquets - Problem

You're managing a flower garden where you need to create beautiful bouquets for a special event! 🌸 Given an integer array bloomDay where bloomDay[i] represents the day when the i-th flower will bloom, and integers m (number of bouquets needed) and k (flowers per bouquet), your task is to find the minimum number of days you need to wait to make exactly m bouquets.

Important constraints:
• Each bouquet must use exactly k adjacent flowers
• Each flower can only be used in one bouquet
• If it's impossible to make m bouquets, return -1

For example, if bloomDay = [1,10,3,10,2], m = 3, and k = 1, you need 3 bouquets with 1 flower each. On day 2, flowers at positions 0, 2, and 4 have bloomed, giving you exactly 3 bouquets!

Input & Output

example_1.py — Basic Case

$ Input: bloomDay = [1,10,3,10,2], m = 3, k = 1

› Output: 3

💡 Note: We need 3 bouquets with 1 flower each. By day 3, flowers at positions 0 (bloomed day 1), 2 (bloomed day 3), and 4 (bloomed day 2) are available, giving us exactly 3 bouquets.

example_2.py — Adjacent Flowers Required

$ Input: bloomDay = [1,10,3,10,2], m = 3, k = 2

› Output: -1

💡 Note: We need 3 bouquets with 2 adjacent flowers each (total 6 flowers), but we only have 5 flowers in the garden. It's impossible to make 3 bouquets.

example_3.py — Longer Wait Time

$ Input: bloomDay = [7,7,7,7,12,7,7], m = 2, k = 3

› Output: 12

💡 Note: We need 2 bouquets with 3 adjacent flowers each. By day 7, positions 0-2 and 3-5 can form bouquets, but position 4 blooms on day 12. So we need to wait until day 12.

Visualization

Tap to expand

Understanding the Visualization

Initial Garden

All flowers are buds, waiting to bloom according to their schedule

Binary Search Range

We know the answer is between day 1 and the latest bloom day

Check Middle Day

For each candidate day, count how many complete bouquets we can make

Narrow Search

If we can make enough bouquets, try an earlier day. Otherwise, try a later day

Key Takeaway

🎯 Key Insight: Binary search works because if we can make enough bouquets on day X, we can definitely make them on any day > X (monotonic property)!

Time & Space Complexity

Time Complexity

⏱️

O(n × log(max(bloomDay)))

Binary search takes log(max(bloomDay)) iterations, and each iteration requires O(n) to check if bouquets can be made

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for binary search variables

✓ Linear Space

Constraints

1 ≤ bloomDay.length ≤ 10⁵
1 ≤ bloomDay[i] ≤ 10⁹
1 ≤ m, k ≤ bloomDay.length
Important: Each bouquet needs exactly k adjacent flowers

Asked in

G Google 28 a Amazon 22 ⊞ Microsoft 15 f Meta 12

The optimal solution uses binary search on the answer with time complexity O(n log(max_day)). The key insight is recognizing that if we can make m bouquets on day X, we can definitely make them on any day after X. This monotonic property allows us to binary search the minimum day instead of checking every day sequentially.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Answer (Optimal)	O(n × log(max(bloomDay)))	O(1)	Binary search the minimum day since the problem has monotonic property
Brute Force (Check Every Day)	O(n × max(bloomDay))	O(1)	Check each day from 1 to max bloom day and count bouquets possible

Binary Search on Answer (Optimal) — Algorithm Steps

Check if it's possible to make m bouquets (if m*k > n, return -1)
Set search range: left = 1, right = max(bloomDay)
While left < right:
- Calculate mid = (left + right) / 2
- Check if we can make m bouquets by day mid
- If yes, search left half: right = mid
- If no, search right half: left = mid + 1
Return left as the minimum day

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Range

Search space: [1, 10]. Mid = 5, check if day 5 works

First Split

Day 5 works, so answer is in [1, 5]. New mid = 3

Final Split

Day 3 works, narrow to [1, 3]. Continue until we find minimum

Code -

solution.c — C

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

int canMakeBouquets(int* bloomDay, int n, int day, int m, int k) {
    int bouquets = 0;
    int consecutive = 0;
    
    for (int i = 0; i < n; i++) {
        if (bloomDay[i] <= day) {
            consecutive++;
            if (consecutive == k) {
                bouquets++;
                consecutive = 0;
            }
        } else {
            consecutive = 0;
        }
    }
    
    return bouquets >= m;
}

int minDays(int* bloomDay, int n, int m, int k) {
    if (m * k > n) return -1;
    
    int left = 1;
    int right = bloomDay[0];
    for (int i = 1; i < n; i++) {
        if (bloomDay[i] > right) {
            right = bloomDay[i];
        }
    }
    
    while (left < right) {
        int mid = left + (right - left) / 2;
        if (canMakeBouquets(bloomDay, n, mid, m, k)) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    
    return left;
}

int main() {
    int bloomDay[] = {1, 10, 3, 10, 2};
    int n = 5, m = 3, k = 1;
    printf("%d\n", minDays(bloomDay, n, m, k));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × log(max(bloomDay)))

Binary search takes log(max(bloomDay)) iterations, and each iteration requires O(n) to check if bouquets can be made

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for binary search variables

✓ Linear Space

Constraints

1 ≤ bloomDay.length ≤ 10⁵
1 ≤ bloomDay[i] ≤ 10⁹
1 ≤ m, k ≤ bloomDay.length
Important: Each bouquet needs exactly k adjacent flowers

67.2K Views

Medium-High 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

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Binary Search on Answer (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler