Minimum Days to Make M Bouquets Binary Search Optimal Solution

Problem Statement❯

You are given an array bloomDay[] where bloomDay[i] represents the day on which the i-th flower will bloom. Your task is to determine the minimum number of days required to make m bouquets, where each bouquet requires k adjacent bloomed flowers.

You can only use a flower if it has bloomed on or before the day you're checking.
You must use exactly k adjacent flowers to make each bouquet.

If it's not possible to make m bouquets, return -1.

Examples❯

Bloom Day Array	m	k	Output	Description
[1, 10, 3, 10, 2]	3	1	3	On day 3, flowers at indices 0, 2, and 4 are bloomed. 3 bouquets possible.
[1, 10, 3, 10, 2]	3	2	-1	Not enough adjacent flowers to form 3 bouquets of 2 flowers.
[7, 7, 7, 7, 12, 7, 7]	2	3	12	Day 12 is the earliest when two bouquets of 3 adjacent flowers can be made.
[1000000000, 1000000000]	1	1	1000000000	Only one flower needed, take the earliest available.
[1, 10, 2, 9, 3, 8]	2	2	9	Day 9 gives two pairs of adjacent bloomed flowers: (2,3) and (4,5)
[1]	1	1	1	One flower, one bouquet needed — return 1.
[1]	2	1	-1	Only one flower, but two bouquets required — not possible.
[]	1	1	-1	Empty array — can't make any bouquets.

Solution❯

This problem is about figuring out the minimum number of days required to make m bouquets, where each bouquet is formed from k adjacent flowers that have bloomed.

Understanding the Setup

We are given a list of bloom days for each flower. A flower can only be used to form a bouquet on or after the day it blooms. For every bouquet, we need exactly k adjacent flowers. If they're not next to each other, we cannot use them in the same bouquet.

How to Think About It

Imagine checking a particular day — let's say day 6. You can only use flowers that bloom on or before day 6. Now go through the array, and every time you see k or more adjacent bloomed flowers, you make one bouquet. Count how many bouquets you can make this way. If you can make at least m bouquets, then day 6 is a valid answer.

Our goal is to find the minimum such day. So, instead of checking each day one by one (which would be slow), we use binary search between the smallest and largest bloom days. At each step, we check if it’s possible to make enough bouquets by that day. If yes, we try an earlier day (move left); if not, we try a later day (move right).

Special Cases to Consider

Not Enough Flowers: If m × k is greater than the total number of flowers, it's impossible to make that many bouquets. We return -1.
All Flowers Bloom Late: If flowers bloom very late (e.g., all values are huge), the answer may be a large number, but binary search helps us get there quickly.
Empty Array: If the input array is empty, no bouquets can be made. We return -1.
Edge Size Matching: If the total number of flowers is exactly m × k, then we must use every flower and they must be positioned in a way that allows adjacency.

This approach gives us a clean and efficient solution with time complexity O(n × log(max bloom day)), where n is the number of flowers.

Algorithm Steps❯

Set low = minimum bloom day, high = maximum bloom day.
Perform binary search while low ≤ high.
Set mid = (low + high) / 2.
Check if it’s possible to make m bouquets in mid days using a helper function:

Traverse bloom days. Count consecutive bloomed roses (i.e., arr[i] ≤ mid).
Every time you collect k adjacent, increment bouquet count and reset count.
If bouquet count ≥ m, return true.

If possible, store mid as answer and move high = mid - 1.
Else move low = mid + 1.

Code

Java

Python

JavaScript

C++

Kotlin

Swift

Php

public class Bouquets {
  public static boolean canMakeBouquets(int[] bloomDay, int m, int k, int day) {
    int bouquets = 0, flowers = 0;
    for (int b : bloomDay) {
      if (b <= day) {
        flowers++;
        if (flowers == k) {
          bouquets++;
          flowers = 0;
        }
      } else {
        flowers = 0;  // Reset if bloom not ready
      }
    }
    return bouquets >= m;
  }

  public static int minDays(int[] bloomDay, int m, int k) {
    if ((long)m * k > bloomDay.length) return -1;
    int low = Integer.MAX_VALUE, high = Integer.MIN_VALUE;
    for (int day : bloomDay) {
      low = Math.min(low, day);
      high = Math.max(high, day);
    }
    int ans = -1;
    while (low <= high) {
      int mid = low + (high - low) / 2;
      if (canMakeBouquets(bloomDay, m, k, mid)) {
        ans = mid;
        high = mid - 1;
      } else {
        low = mid + 1;
      }
    }
    return ans;
  }

  public static void main(String[] args) {
    int[] bloom = {1, 10, 3, 10, 2};
    int m = 3, k = 1;
    System.out.println("Minimum Days: " + minDays(bloom, m, k));
  }
}

Time Complexity❯

Case	Time Complexity	Explanation
Best Case	O(n)	In the best case, the first binary search guess gives a valid answer after a single bouquet check.
Average Case	O(n log(max_day - min_day))	Binary search runs in log(max_day - min_day) steps and each step checks the full array to count bouquets.
Worst Case	O(n log(max_day - min_day))	Binary search iterates across the entire range of possible days, checking all n roses each time.

Space Complexity❯

O(1)

Explanation: Only a few variables are used; no extra space is needed apart from input.

⬅ Previous TopicKoko Eating Bananas

Next Topic ⮕Find the Smallest Divisor Given a Threshold