LeetCode-1482 Minimum Number of Days to Make m Bouquets

Description

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.

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

Example

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

Submissions

解题思路采用二分查找，但是比较特殊的是，我们针对天数进行二分查找，因为这里有一个隐含的条件，随着天数的增加，开花的数量递增，而花开的越多，越可能满足条件，所以我们对天数进行二分查找，找到第一个满足条件的天数。

其次我们将bloomDay转化为集合去除重复元素，然后转换为列表再排序，组成Days列表，对Days列表开始进行二分查找。

每次查找时，我们需要判断这个天数是否符合条件，我们定义isans方法来判断。在isans中，遍历bloomDay，判断这朵花当前有没有开，同时开始计数；遍历结束后判断是否有大于等于m个，且判断是否有不重叠的连续k个开花的子数组，如果有，则符合条件，返回True，否则返回False。

二分结束之后，我们再判断此时的天数是不是满足条件，满足返回这个天数，不满足则返回-1。

实现代码如下：

class Solution:
    def minDays(self, bloomDay: List[int], m: int, k: int) -> int:
        n = len(bloomDay)
        #花朵总数不够，返回-1
        if n < m * k:
            return -1
        #将可能出现的天数转换为set去重，再转化为列表进行排序
        days = list(set(bloomDay))
        days.sort()
        day_n = len(days)
        #开始二分，找到最小的满足条件的天数
        left = 0
        right = day_n-1
        while left < right:
            mid = left + (right-left)//2
            if self.isans(days[mid],n,bloomDay,m,k):
                right = mid
            else:
                left = mid+1
        #如果找到了，即为这个天数，如果没找到，则返回-1
        if self.isans(days[left],n,bloomDay,m,k):
            return days[left]
        else:
            return -1
        
    #判断第day天能否成功制作m束花，返回True或False
    def isans(self,day,n,bloomDay,m,k):
        #temp存放当前连续开花的个数
        temp = 0
        #bunch表示当前制作成的花束数
        bunch = 0
        for flower in bloomDay:
            #判断这朵花现在开没开
            if flower <= day:
                if temp == k:
                    bunch += 1
                    temp = 0
                temp += 1
            else:
                if temp == k:
                    bunch += 1
                temp = 0
        #考虑到最后正好k朵连续的情况
        if temp == k:
            bunch += 1
        return True if bunch >= m else False

参考