标签：
天，这题我已经没有底气高呼“水”了。。。
题目的地址：
https://leetcode.com/problems/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?
题目解析：
关键是线性时间。开头我试图通过动态规划定义子问题来解决，然而这并没有什么卵用，怀疑自己已经患上了一定程度的动态规划病，需要重读CLRS回炉一番
其实有第二个关键点。均摊复杂度和严格复杂度，对于“线性时间内解决”这个要求而言，并没有什么不同的地方。
第三个关键点，就是这是一个动态维护的队列，你要在不重新遍历队中元素的情况下维护一个最值。
不知道各位是否做过O(1)时间内维护一个栈中最值的问题，如果没有，可以看看这篇老文：
【原创】leetCodeOj --- Min Stack 解题报告
那位说了，刚才还讲本质上是动态队列，现在你拿栈出来坑蒙拐骗，放学别走
别急别急，不是还能用栈模拟队列吗？
两个栈，队列的push操作，就把元素压到栈1。队列的pop操作，首先检查栈2是否非空，若栈2有元素，直接pop。若栈2无元素，则把当前栈1中全部的元素压进栈2。
这样，我们能够维护一个栈中的最值，就能维护一个队列中的最值。
因为当前队列中的全部元素都分布在这两个栈中，因此，这两个栈的最值再比一轮，就是最后的最值。
又有人问了，pop一次，栈2有东西还好，若没有，就得捣腾半天，把栈1的元素挨个压进栈2，这算哪门子线性时间？
还真是线性时间，别忘了均摊复杂度
每个元素，进队被压进一次栈1，出队时被压进栈2一次，算上弹出操作2次，一共只有4次操作。
一共n个元素
那就是4n个操作
不就是线性吗？
关键在于，一次实际的操作可能只有弹出一次，而压栈的操作被集成在某次弹出时集中执行了。
具体代码：
public class Solution { public int[] maxSlidingWindow(int[] nums, int k) { if (nums.length == 0) { return nums; } int[] res = new int[nums.length - k + 1]; MinQueue queue = new MinQueue(); for (int i = 0; i < k; i ++) { queue.push(nums[i]); } res[0] = queue.getMax(); int index = 1; for (int i = k; i < nums.length; i ++) { queue.pop(); queue.push(nums[i]); res[index ++] = queue.getMax(); } return res; } class MinQueue { LinkedList<Integer> stack1 = new LinkedList<Integer>(); LinkedList<Integer> stack2 = new LinkedList<Integer>(); LinkedList<Integer> maxOne = new LinkedList<Integer>(); LinkedList<Integer> maxTwo = new LinkedList<Integer>(); public void push(Integer item) { pushOne(item); } public Integer pop() { Integer res = null; if (stack2.size() == 0) { while (stack1.size() != 0) { pushTwo(popOne()); } } res = stack2.pop(); maxTwo.pop(); return res; } public Integer getMax() { Integer one = maxOne.peek(); Integer two = maxTwo.peek(); if (one == null) { return two; } else if (two == null){ return one; } return one > two ? one : two; } private Integer popOne() { Integer res = null; maxOne.pop(); res = stack1.pop(); return res; } private void pushOne(Integer item) { stack1.push(item); if (stack1.size() == 1) { maxOne.push(item); } else { Integer front = maxOne.peek(); if (front < item) { maxOne.push(item); } else { maxOne.push(front); } } } private void pushTwo(Integer item) { stack2.push(item); if (stack2.size() == 1) { maxTwo.push(item); } else { Integer front = maxTwo.peek(); if (front < item) { maxTwo.push(item); } else { maxTwo.push(front); } } } } }
【原创】leetCodeOj --- Sliding Window Maximum 解题报告
标签：
原文地址：http://www.cnblogs.com/shadowmydx/p/4770856.html
