2021-5-09 力扣每日一题

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数组的长度小于m*k的时候，是不可能摘到m束花的，而如果是大于等于的话，一定能摘到。

​ 那么我们就针对能摘到的情况，将bloomDay数组看做一个长度为n的滑窗，其中包含m个长度为k的小窗口，当然这些窗口怎么摆放，就是我们需要实现的了，存在一种摆放方式可以让窗口中的最大值最小。

​ 思路很清晰，但是怎么实现呢？我们需要维护m个大小为k的窗口，这m个窗口还没有规律可言，只能枚举，所以这几乎是一个不可能实现的思路。（可能我太菜了）这个思路就放一放吧，如果有大佬可以实现这个思路的解法的话可以告诉我。相互学习学习。

【二分查找】

​ 很多问题我们正方向思考可能很难，但是如果反方向思考就可能会简单点。这个就是一个很典型的反方向思考更优的题目。

​ 我们正向思维去寻找合理的方案，倒不如倒着想，我们给定一个值，假设我们最多可以等 a 天，看所给的方案能否满足即可。我们只需要将a的值尽量小就可以了。

​ 有了这个思路，我们就需要新写一个辅助函数，来判断我们如果等a天的话，是否存在合理的方案。很明显，如果a很大的话，我们一定是有合理方案的，a最大就是bloomDay数组的最大值，同理，a最小就是bloomDay的最小值。

​ 那么，辅助函数怎么写？我们将我们可以忍受的天数传进去，接着遍历bloomDay数组，如果某个值大于这个天数，我们记录一下它的下标，和前一个大于这个天数的下标相减，这样得出两个大于这个天数中间的个数，接着对个数除以k下取整就得到这中间可以穿插多少个宽度为k的窗口，再将m减去这个值，当m小于等于0的时候，说明在某个忍受天数下，是可以摘到m束花的。反之就不可以摘到m束花。

Java代码：

/** 
    * @Description: 力扣1482题题解
    * @return: 返回结果
    * @Author: Mr.Gao
    * @Date: 2021/5/9 
    */
    public int minDays(int[] bloomDay, int m, int k) {
        int n = bloomDay.length;
        if(n<m*k){
            return -1;
        }
        int min = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;
        //找最大值和最小值
        for (int i = 0; i < n; i++) {
            if(bloomDay[i]<min){
                min = bloomDay[i];
            }
            if(bloomDay[i]>max){
                max = bloomDay[i];
            }
        }
        int left = min;
        int right = max;
        //二分查找模板
        while(left<right){
            //因为left和right都没有超过int，所以中间值也不可能超过int
            //但是left+right可能超过int，为了稳健性。我们一般采取下面的写法
            //这是历史上一个很著名的bug，求中间值的时候养成习惯这么写最好。
            int mid = left+(right-left)/2;
            
            if(f(bloomDay,m,k,mid)){
                right = mid;
            }else{
                left = mid+1;
            }
        }
        //最后我们返回left即可
        return left;
    }
    public boolean f(int[] bloomDay,int m,int k,int size){
        int n = bloomDay.length;
        int temp=0;
        //假定第一个大于size的下标是-1.
        int pro = -1;
        for (int i = 0; i < n; i++) {
            if(bloomDay[i]>size){
                //计算两个大于size的值中间的个数
                temp = i-pro-1;
                m-=temp/k;
                if(m<=0){
                    return true;
                }
                pro = i;
            }
        }
        /**
         * 这里还要多进行判断一次，因为如果最后几位是小于size的
         * 我们需要将最后几位也算进去
         * */
        temp = n-pro-1;
        m-=temp/k;
        if(m<=0){
            return true;
        }
        return false;
    }