Formatted question description: https://leetcode.ca/all/1482.html

# 1482. Minimum Number of Days to Make m Bouquets (Medium)

Given an integer array bloomDay, an integer m and an integer k.

We need to make m bouquets. To make a bouquet, you need to use k adjacent flowers from the garden.

The garden consists of n flowers, the ith flower will bloom in the bloomDay[i] and then can be used in exactly one bouquet.

Return the minimum number of days you need to wait to be able to make m bouquets from the garden. If it is impossible to make m bouquets return -1.

Example 1:

Input: bloomDay = [1,10,3,10,2], m = 3, k = 1
Output: 3
Explanation: Let's see what happened in the first three days. x means flower bloomed and _ means flower didn't bloom in the garden.
We need 3 bouquets each should contain 1 flower.
After day 1: [x, _, _, _, _]   // we can only make one bouquet.
After day 2: [x, _, _, _, x]   // we can only make two bouquets.
After day 3: [x, _, x, _, x]   // we can make 3 bouquets. The answer is 3.


Example 2:

Input: bloomDay = [1,10,3,10,2], m = 3, k = 2
Output: -1
Explanation: We need 3 bouquets each has 2 flowers, that means we need 6 flowers. We only have 5 flowers so it is impossible to get the needed bouquets and we return -1.


Example 3:

Input: bloomDay = [7,7,7,7,12,7,7], m = 2, k = 3
Output: 12
Explanation: We need 2 bouquets each should have 3 flowers.
Here's the garden after the 7 and 12 days:
After day 7: [x, x, x, x, _, x, x]
We can make one bouquet of the first three flowers that bloomed. We cannot make another bouquet from the last three flowers that bloomed because they are not adjacent.
After day 12: [x, x, x, x, x, x, x]
It is obvious that we can make two bouquets in different ways.


Example 4:

Input: bloomDay = [1000000000,1000000000], m = 1, k = 1
Output: 1000000000
Explanation: You need to wait 1000000000 days to have a flower ready for a bouquet.


Example 5:

Input: bloomDay = [1,10,2,9,3,8,4,7,5,6], m = 4, k = 2
Output: 9


Constraints:

• bloomDay.length == n
• 1 <= n <= 10^5
• 1 <= bloomDay[i] <= 10^9
• 1 <= m <= 10^6
• 1 <= k <= n

Related Topics:
Array, Binary Search

## Solution 1. Binary Answer

• we can detect whether a given day A[i] can form the required output in O(N) time.
• we can try out each unique day in ascending order. The first one that satisfies the requirement is the answer.

But this would require O(N^2) time complexity.

Instead of trying each unique data linearly, we can binary search on those unique days to reduce the time complexity.

// OJ: https://leetcode.com/problems/minimum-number-of-days-to-make-m-bouquets/

// Time: O(NlogU) where U is the count of unique days
// Space: O(N)
class Solution {
bool valid(vector<int> &A, int n, int m, int k) {
int N = A.size(), cnt = 0, j = 0;
while (j < N) {
int i = j;
while (j < N && j - i < k && A[j] <= n) ++j;
if (j - i == k) ++cnt;
if (cnt >= m) return true;
while (j < N && A[j] > n) ++j;
}
return false;
}
public:
int minDays(vector<int>& A, int m, int k) {
if (A.size() < m * k) return -1;
set<int> s(begin(A), end(A));
vector<int> u(begin(s), end(s));
int L = 0, R = u.size() - 1;
while (L <= R) {
int M = (L + R) / 2;
if (valid(A, u[M], m, k)) R = M - 1;
else L = M + 1;
}
return u[L];
}
};


## Solution 2. Binary Answer

// OJ: https://leetcode.com/problems/minimum-number-of-days-to-make-m-bouquets/

// Time: O(Nlog(max(A)))
// Space: O(1)
// Ref: https://leetcode.com/problems/minimum-number-of-days-to-make-m-bouquets/discuss/686316/JavaC%2B%2BPython-Binary-Search
class Solution {
public:
int minDays(vector<int>& A, int m, int k) {
int N = A.size(), L = 1, R = 1e9;
if (N < m * k) return -1;
while (L <= R) {
int M = (L + R) / 2, cnt = 0, cur = 0;
for (int j = 0; j < N; ++j) {
if (A[j] > M) cur = 0;
else if (++cur >= k) {
++cnt;
cur = 0;
}
}
if (cnt < m) L = M + 1;
else R = M - 1;
}
return L;
}
};


Java

class Solution {
public int minDays(int[] bloomDay, int m, int k) {
int length = bloomDay.length;
if (length < m * k)
return -1;
int[] maxArray = maxSlidingWindow(bloomDay, k);
int low = bloomDay, high = bloomDay;
for (int i = 1; i < length; i++) {
low = Math.min(low, bloomDay[i]);
high = Math.max(high, bloomDay[i]);
}
while (low < high) {
int days = (high - low) / 2 + low;
boolean flag = canMake(bloomDay, maxArray, days, m, k);
if (flag)
high = days;
else
low = days + 1;
}
return low;
}

public int[] maxSlidingWindow(int[] nums, int k) {
int length = nums.length;
if (length == 0 || k == 0)
return new int;
if (k == 1)
return nums;
int windowsCount = length - k + 1;
int[] maxArray = new int[windowsCount];
ArrayDeque<Integer> deque = new ArrayDeque<Integer>();
for (int i = 0; i < k; i++) {
int num = nums[i];
while (!deque.isEmpty() && nums[deque.getLast()] < num)
deque.removeLast();
}
maxArray = nums[deque.getFirst()];
for (int i = k; i < length; i++) {
int windowIndex = i - k + 1;
if (!deque.isEmpty() && deque.getFirst() == i - k)
deque.removeFirst();
int num = nums[i];
while (!deque.isEmpty() && nums[deque.getLast()] < num)
deque.removeLast();
maxArray[windowIndex] = nums[deque.getFirst()];
}
return maxArray;
}

public boolean canMake(int[] bloomDay, int[] maxArray, int days, int m, int k) {
int length = bloomDay.length;
int maxStart = length - k;
int index = 0;
while (index <= maxStart && m > 0) {
if (maxArray[index] <= days) {
m--;
index += k;
} else
index++;
}
return m == 0;
}
}