解题报告-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;
}
}