解题报告-683. K Empty Slots

There is a garden with N slots. In each slot, there is a flower. The N flowers will bloom one by one in N days. In each day, there will be exactly one flower blooming and it will be in the status of blooming since then.
Given an array flowers consists of number from 1 to N. Each number in the array represents the place where the flower will open in that day.
For example, flowers[i] = x means that the unique flower that blooms at day i will be at position x, where i and x will be in the range from 1 to N.
Also given an integer k, you need to output in which day there exists two flowers in the status of blooming, and also the number of flowers between them is k and these flowers are not blooming.
If there isn't such day, output -1.
Example 1:
Input:
flowers: [1,3,2]
k: 1
Output: 2
Explanation: In the second day, the first and the third flower have become blooming.
Example 2:
Input:
flowers: [1,2,3]
k: 1
Output: -1
Note:
The given array will be in the range [1, 20000].

解法一: 时间O(N * LogN) 空间 O(N)

思路: 对于任意一个位置i, 假设i开花了, i 需要看下左侧离它最近的开花位置是不是i - k - 1, 或者看下右侧离它最近的位置是不是i + k + 1，

所以是个搜索问题. 搜索的话，我们知道有上下界查找，在java中，查数A的上界即找第一个大于该数的值，下界即找最后一个小于该数的值, 前提是整个数有序

而在本题中，我们可以使用treeset保存开花位置，每输入一个新的位置，在TreeSet中找左侧离该位置最近的位置，或者右侧离该位置最近的位置，即查找上下界

判断距离上下界的距离是否为k，第一个满足条件的为结果

class Solution {
    public int kEmptySlots(int[] flowers, int k) {
        TreeSet<Integer> tree = new TreeSet<>();
        int day = 0;
        for (int flower : flowers) {
            ++day;
            tree.add(flower);
            Integer lower = tree.lower(flower);
            if (lower != null && flower - lower - 1 == k) return day;
            Integer higher = tree.higher(flower);
            if (higher != null && higher - flower - 1 == k) return day;
        }
        return -1;
    }
}

解法二: 时间O(N) 空间O(N)

思路: 维护每个位置开花的日期, 如果存在某个区间符合条件，那么需要满足a[left] < min(a[left + 1] ... a[left + k]) && a[right] < min(a[left + 1] ... a[left + k])

可以考虑维护这个区间内的最小值，用两端的值跟区间内最小值比较，难点是该如何维护这个数据结构?

a[left] 要么比区间内的最小值大,要么等于,要么小于

因为我们要维护区间内的最小值，区间内的淘汰规则应该是小的淘汰大的，

所以如果a[left]比区间内的最小值小，那么假设我们维护了最小值队列，那么a[left]应该在区间前面

如果a[left]比区间内最小值大，那么它不会出现在最小值队列中

假设我们维护两个队列，一个存原始数据， 一个存区间内的最小值

假设left = 0, 第一个区间的right 应该为 k + 1

在入队第k个元素后，我们构造了前k个数的最小队列, a[left] 可能在队列中，也可能不在

我们先从原始队列中弹出a[left], 然后如果a[left] == 最小值队列的头部元素值，则从最小值队列中也把该值弹出

然后比较 a[left] 与 最小值队列当前的队头值，然后比较a[right]和最小值队头值， 如果满足条件a[left] < min(a[left + 1] ... a[left + k]) && a[right] < min(a[left + 1] ... a[left + k])

则得到一个可能的结果，最终从这些结果中，挑值最小的即为最终解

class Solution {
    public int kEmptySlots(int[] flowers, int k) {
        int[] days = new int[flowers.length];
        for (int i = 0; i < days.length; i++) {
            days[flowers[i] - 1] = i + 1;
        }
        int ans = Integer.MAX_VALUE;
        MinQueue<Integer> mins = new MinQueue<>();
        for (int i = 0; i < days.length; i++) {
            mins.addLast(days[i]);
            if (i >= k) {
                Integer x = mins.pollFirst();
                if (mins.isEmpty()) {
                    if (i + 1 < days.length) {
                        ans = Math.min(ans, Math.max(x, days[i + 1]));
                    }
                } else {
                    if (x < mins.min() && i + 1 < days.length && days[i + 1] < mins.min()) {
                        ans = Math.min(ans, Math.max(x, days[i + 1]));
                    }
                }
            }
        }
        if (ans == Integer.MAX_VALUE) {
            ans = -1;
        }
        return ans;
    }
}
class MinQueue<E extends Comparable<E>> extends ArrayDeque<E> {
    Deque<E> mins;
    public MinQueue() {
        mins = new ArrayDeque<E>();
    }
    @Override
    public void addLast(E x) {
        super.addLast(x);
        while (mins.peekLast() != null && x.compareTo(mins.peekLast()) < 0) {
            mins.pollLast();
        }
        mins.addLast(x);
    }
    @Override
    public E pollFirst() {
        E x = super.pollFirst();
        if (0 == x.compareTo(mins.peekFirst())) {
            mins.pollFirst();
        }
        return x;
    }
    public E min() {
        return mins.peekFirst();
    }
}

解法三: 时间O(N) 空间O(N)

思路: 与解法二思路相同, 维护K + 2大小的区间, 假设有两个满足条件的区间

[k1, k2] 和 [k3, k4], 可以得到一个结论: 这两个区间不能重合

因为假设两区间重合 k1 < k3 < k2 < k4, 那么k3 和 k4 中间存在一个比它俩都小的值，则[k3, k4]不满足解的条件，与已知条件矛盾

所以不可能重合.

同时对于一个区间内，如果遇到一个位置p, p < k1 或者 p < k2, 那么p之前位置都不可能是解, 此时，我们从p开始重新查找可行解.

class Solution {
    public int kEmptySlots(int[] flowers, int k) {
        int[] days = new int[flowers.length];
        for (int i = 0; i < days.length; i++) {
            days[flowers[i] - 1] = i + 1;
        }
        int left = 0, right = k + 1;
        int ans = Integer.MAX_VALUE;
        search:
            while (right < days.length) {
                for (int j = left + 1; j < right; j++) {
                    if (days[j] < days[left] || days[j] < days[right]) {
                        left = j;
                        right = j + k + 1;
                        continue search;
                    }
                }
                ans = Math.min(ans, Math.max(days[left], days[right]));
                left = right;
                right = left + k + 1;
            }
        if (ans == Integer.MAX_VALUE) ans = -1;
        return ans;
    }
}