239. Sliding Window Maximum

Given an array nums, there is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves right by one position.

For example,
Given nums = [1,3,-1,-3,5,3,6,7], and k = 3.

Window position                Max
---------------               -----
[1  3  -1] -3  5  3  6  7       3
 1 [3  -1  -3] 5  3  6  7       3
 1  3 [-1  -3  5] 3  6  7       5
 1  3  -1 [-3  5  3] 6  7       5
 1  3  -1  -3 [5  3  6] 7       6
 1  3  -1  -3  5 [3  6  7]      7

Therefore, return the max sliding window as [3,3,5,5,6,7].

Note: 
You may assume k is always valid, ie: 1 ≤ k ≤ input array's size for non-empty array.

Follow up:
Could you solve it in linear time?

这道题考查Deque。在top solution里有一个很好的解释：

At each i, we keep "promising" elements, which are potentially max number in window [i-(k-1),i] or any subsequent window. This means

If an element in the deque and it is out of i-(k-1), we discard them. We just need to poll from the head, as we are using a deque and elements are ordered as the sequence in the array

Now only those elements within [i-(k-1),i] are in the deque. We then discard elements smaller than a[i] from the tail. This is because if a[x] <a[i] and x<i, then a[x] has no chance to be the "max" in [i-(k-1),i], or any other subsequent window: a[i] would always be a better candidate.

As a result elements in the deque are ordered in both sequence in array and their value. At each step the head of the deque is the max element in [i-(k-1),i]

总结起来就是在k范围内保证有可能存在的最大数，这是一个下降的单调栈。当最前面的数下标不满足时需要剔除，然后加入新的，res每次添加peek的数。代码如下：

public class Solution {
    private void inDeque(Deque<Integer> deque, int[] nums, int i) {
        while (!deque.isEmpty() && nums[i] >= nums[deque.peekLast()]) {
            deque.removeLast();
        }
        deque.offerLast(i);
    }
    
    private void outDeque(Deque<Integer> deque, int i) {
        if (!deque.isEmpty() && deque.peek() <= i) {
            deque.removeFirst();
        }
    }
    
    public int[] maxSlidingWindow(int[] nums, int k) {
        if (nums == null || nums.length == 0) {
            return new int[0];
        }
        Deque<Integer> deque = new ArrayDeque<Integer>();
        int[] res = new int[nums.length - k + 1];
        for (int i = 0; i < k - 1; i ++) {
            inDeque(deque, nums, i);
        }
        for (int i = k - 1; i < nums.length; i ++) {
            inDeque(deque, nums, i);
            res[i - k + 1] = nums[deque.peek()];
            outDeque(deque, i - k + 1);
        }
        return res;
    }
}

简洁版的如下：

public int[] maxSlidingWindow(int[] a, int k) {		
	if (a == null || k <= 0) {
		return new int[0];
	}
	int n = a.length;
	int[] r = new int[n-k+1];
	int ri = 0;
	// store index
	Deque<Integer> q = new ArrayDeque<>();
	for (int i = 0; i < a.length; i++) {
		// remove numbers out of range k
		while (!q.isEmpty() && q.peek() < i - k + 1) {
			q.poll();
		}
		// remove smaller numbers in k range as they are useless
		while (!q.isEmpty() && a[q.peekLast()] < a[i]) {
			q.pollLast();
		}
		// q contains index... r contains content
		q.offer(i);
		if (i >= k - 1) {
			r[ri++] = a[q.peek()];
		}
	}
	return r;
}