leetcode.1482. 制作 m 束花所需的最少天数---二分

1482. 制作 m 束花所需的最少天数

给你一个整数数组 bloomDay，以及两个整数 m 和 k 。

现需要制作 m 束花。制作花束时，需要使用花园中 相邻的 k 朵花 。

花园中有 n 朵花，第 i 朵花会在 bloomDay[i] 时盛开，恰好 可以用于 一束 花中。

请你返回从花园中摘 m 束花需要等待的最少的天数。如果不能摘到 m 束花则返回 -1 。

示例 1：

输入：bloomDay = [1,10,3,10,2], m = 3, k = 1
输出：3
解释：让我们一起观察这三天的花开过程，x 表示花开，而 _ 表示花还未开。
现在需要制作 3 束花，每束只需要 1 朵。
1 天后：[x, _, _, _, _]   // 只能制作 1 束花
2 天后：[x, _, _, _, x]   // 只能制作 2 束花
3 天后：[x, _, x, _, x]   // 可以制作 3 束花，答案为 3
示例 2：

输入：bloomDay = [1,10,3,10,2], m = 3, k = 2
输出：-1
解释：要制作 3 束花，每束需要 2 朵花，也就是一共需要 6 朵花。而花园中只有 5 朵花，无法满足制作要求，返回 -1 。
示例 3：

输入：bloomDay = [7,7,7,7,12,7,7], m = 2, k = 3
输出：12
解释：要制作 2 束花，每束需要 3 朵。
花园在 7 天后和 12 天后的情况如下：
7 天后：[x, x, x, x, _, x, x]
可以用前 3 朵盛开的花制作第一束花。但不能使用后 3 朵盛开的花，因为它们不相邻。
12 天后：[x, x, x, x, x, x, x]
显然，我们可以用不同的方式制作两束花。
示例 4：

输入：bloomDay = [1000000000,1000000000], m = 1, k = 1
输出：1000000000
解释：需要等 1000000000 天才能采到花来制作花束
示例 5：

输入：bloomDay = [1,10,2,9,3,8,4,7,5,6], m = 4, k = 2
输出：9
 

提示：

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

题解：

首先如果bloomday的长度小于k*m的话，一定不能制作成功，因此我们直接返回-1；

如果大于等于k*m，则一定会制作成功。或许有人会想，它不是规定了必须相邻的花才可制作成一束花吗？
那么在这种情况下一定可以制作成功吗？
是可以的，因为我们大不了等所有的花全部盛开，这时候必定是连续的了，所以必定会制作成功。

在此情况下，我们可以先遍历bloomday数组，找到我们查找的下限和上限，在此区间内进行查找即可，此过程由于下限上限确定，其一个为最小，一个为最大，因此在此范围内查找我们需要的天数，此相当于在有序数组上查找，因此可以使用二分优化查找。
查找的过程中需要一个辅助函数来帮助我们判断当天数为days时是否满足制作m束花的条件，以此来进行增大下限还是减小上限。

注意当days很大时其往往能成功，days很小时往往不能成功。

代码（Java）：

class Solution {
    public int minDays(int[] bloomDay, int m, int k) {
        if(bloomDay.length/k<m){
            return -1;
        }
        int low =Integer.MAX_VALUE ;
        int high = 0;
        for(int i:bloomDay){
            low = Math.min(low,i);
            high = Math.max(high,i);
        }

        while(low<high){
            int days = low + (high-low)/2;
            if(this.can(bloomDay,m,k,days)){
                high = days;
            }
            else{
                low = days + 1;
            }
        }
        return low;
    }
    public static boolean can(int[] bloomDay,int m,int k,int days){
        int flower = 0;//当前成熟的花数
        int bonquet = 0;//当前制作的花束数量
        for(int i:bloomDay){
            if(days>=i){
                flower++;//说明此花成熟了，所以+1
                if(flower==k){//说明可以制作一束花了
                    bonquet++;
                    flower = 0;//需要置为0
                }
            }
            else{
                flower = 0;//因为题目限制必须相邻的才可制作一束花，
  //如果前面的成熟的花不能制作成一束花，当遇到断层时其flower需要置为0，重新计数
            }
        }
        if(bonquet>=m){
            return true;
        }
        return false;
    }
}

代码（C语言）：

bool success(int* bloomDay,int bloomDaySize,int m,int k,int days)
{
    int flower = 0;
    int bonquet = 0;
    for(int i=0;i<bloomDaySize && bonquet<m;i++)
    {
        if(bloomDay[i]<=days)
        {
            flower++;
            if(flower==k)
            {
                bonquet++;
                flower = 0;
            }
        }
        else
        {
            flower = 0;            
        }
    }
    if(bonquet>=m)
    {
        return 1;
    }
    return 0;
}
int minDays(int* bloomDay, int bloomDaySize, int m, int k){
    if(m>bloomDaySize/k)
    {
        return -1;
    }
    int max = 0;
    int min = INT_MAX;
    for(int i=0;i<bloomDaySize;i++)
    {
        min = fmin(min,bloomDay[i]);
        max = fmax(max,bloomDay[i]);
    }

    while(min<max)
    {
        int days = min+(max-min)/2;
        if(success(bloomDay,bloomDaySize,m,k,days))
        {
            max = days;
        }
        else
        {
            min = days + 1;
        }
    }
    
    return max;
}