LeetCode 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. Return the max sliding window.

Example:

Input: nums = [1,3,-1,-3,5,3,6,7], and k = 3
Output: [3,3,5,5,6,7] 
Explanation: 

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

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

Follow up:
Could you solve it in linear time?

---

最最简单的暴力brute force方法就是遍历整个数组的时候，对当前开始的size为k的window取最大。取最大可以简单粗暴地遍历一遍进行比较，这样是O(nk)的复杂度，但也可以直接用个heap来存然后取最top，也就是降到了O(nlogk)的复杂度。代码如下：

Runtime: 1700 ms, faster than 5.20% of C++ online submissions for Sliding Window Maximum.

Memory Usage: 179.7 MB, less than 6.56% of C++ online submissions for Sliding Window Maximum.

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        if (nums.empty()) {
            return vector<int>();
        }
        vector<int> result;
        for (int i = 0; i < nums.size() - k + 1; i++) {
            priority_queue<int> window(nums.begin() + i, nums.begin() + i + k);
            result.push_back(window.top());
        }
        return result;
    }
};

另一种方法是采用deque，deque是双向队列，可以在任意一端进行push和pop。采用deque的思想在于，我们在deque中存放一段在window size范围内的非递增序列（也就是head元素是整个deque中最大的元素），每次遇到新的数字都把它push到deque里，并且如果这个数字比deque中的某些数字大，就把比它小的都pop掉，也就是相当于从tail开始把所有比当前数字小的都删掉，最后每次iteration的时候deque里的front就是目前window size中最大的元素。需要注意的就是要保证deque中的front一定要在window size范围内（对于这个实现方式的理解还需要更深刻一些）。这种方法的时间和空间复杂度都是O(n)，其实这里刚开始有点不是特别理解时间复杂度为O(n)，因为感觉在for循环里面也有个while，假如原数组是个递增的序列，那不是会while里面每次都运行k吗？其实并不会，因为在后面更大的数字被加入的时候，前面的就被remove了，所以其实相当于是数组中每个元素都被add和remove到deque里面一次，所以是O(n)。

https://www.zhihu.com/question/314669016/answer/663930108 这个链接中有很好的动画展示，真的非常易懂。

C++：

Runtime: 56 ms, faster than 86.96% of C++ online submissions for Sliding Window Maximum.

Memory Usage: 13.1 MB, less than 77.05% of C++ online submissions for Sliding Window Maximum.

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        if (nums.empty()) {
            return vector<int>();
        }
        vector<int> result;
        deque<int> dq;
        for (int i = 0; i < nums.size(); i++) {
            // should use dq.back() because it might be smaller than first
            // but larger than remaining
            while (!dq.empty() && nums[i] > dq.back()) {
                dq.pop_back();
            }
            dq.push_back(nums[i]);
            if (i >= k - 1) {
                result.push_back(dq.front());
                // if the current front is the first elem in the window
                // we cannot keep it in the next iteration, so pop it
                if (nums[i - k + 1] == dq.front()) {
                    dq.pop_front();
                }
            }
        }
        
        return result;
    }
};

Java：

Runtime: 22 ms, faster than 34.04% of Java online submissions for Sliding Window Maximum.

Memory Usage: 60.4 MB, less than 28.40% of Java online submissions for Sliding Window Maximum.

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        int[] result = new int[nums.length - k + 1];
        Deque<Integer> deque = new ArrayDeque<>();
        for (int i = 0; i < nums.length; i++) {
            // pop the elements that are not larger than current element
            // start from the tail of the deque
            while (!deque.isEmpty() && nums[i] > deque.getLast()) {
                deque.removeLast();
            }
            deque.addLast(nums[i]);
            if (i >= k - 1) {
                // store the head of the deque as the result
                result[i - k + 1] = deque.getFirst();
                // remove the head if it will not be in the window the next time
                if (nums[i - k + 1] == deque.getFirst()) {
                    deque.removeFirst();
                }
            }
        }
        return result;
    }
}

最后一种方法是有一点动态规划的思想。我们先把整个数组分成大小为k的几组，最后一组的个数可以小于k。然后我们分别对每组中的元素（注意是同一组）求出从左到右的max和从右到左的max（有那么一点点像trapping rain water）。我们在slide整个数组的时候，这个window可能有两种情况，一种是所有元素都在刚刚分出来的同一个组中，另一种是分别在两个不同的组中：

假如当前的窗口是从i到j，并且i是某一组的起始元素，那么当前window的max就是left[j]或者right[i]

假如i不是起始元素，那么一定是第二种情况，那么当前window的max应该是max(left[j], right[i])，因为left[j]是j所在的这组元素从左往右最大值，right[i]是i所在的这组元素从右往左的最大值，二者之中的最大一定就是当前window被分开的两边的最大值的其中之一。

两种情况可以合并，其实就直接是max(left[j], right[i])。这种做法的时空复杂度也都是O(n)。

Runtime: 56 ms, faster than 86.96% of C++ online submissions for Sliding Window Maximum.

Memory Usage: 14.3 MB, less than 22.95% of C++ online submissions for Sliding Window Maximum.

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        if (nums.empty()) {
            return vector<int>();
        }
        vector<int> result, left, right;
        int max_left, max_right;
        for (int i = 0; i < nums.size(); i++) {
            if (i % k == 0) {
                max_left = nums[i];
            }
            else {
                max_left = max(max_left, nums[i]);
            }
            left.push_back(max_left);
        }
        
        for (int i = nums.size() - 1; i >= 0; i--) {
            if (i % k == 0) {
                max_right = nums[i];
            }
            else {
                max_right = max(max_right, nums[i]);
            }
            right.push_back(max_right);
        }
        reverse(right.begin(), right.end());
        
        for (int i = 0; i < nums.size() - k + 1; i++) {
            result.push_back(max(left[i + k - 1], right[i]));
        }
        return result;
    }
};

上面代码中进行了两次for循环得到left和right数组，其实可以放在一个循环里，但是懒得写了……

然后补java的时候就把两次for循环合一起了，结果各种下标搞死我了，但主要感觉还是对这个做法的理解不够深入所以才会很晕，各种试和抄答案。

Runtime: 7 ms, faster than 90.96% of Java online submissions for Sliding Window Maximum.

Memory Usage: 60.1 MB, less than 31.52% of Java online submissions for Sliding Window Maximum.

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        int[] result = new int[nums.length - k + 1];
        int[] left = new int[nums.length];
        int[] right = new int[nums.length];
        for (int i = 0; i < nums.length; i++) {
            if (i % k == 0) {
                left[i] = nums[i];
            } else {
                left[i] = Math.max(left[i - 1], nums[i]);
            }
            int r = nums.length - i - 1;
            // the start of r is the last element of a block, or, it is the last element
            if ((r + 1) % k == 0 || r == nums.length - 1) {
                right[r] = nums[r];
            } else {
                right[r] = Math.max(right[r + 1], nums[r]);
            }
        }
        
        // the result is the max of the left[rightElement] and right[leftElement]
        for (int i = 0; i < nums.length - k + 1; i++) {
            result[i] = Math.max(left[i + k - 1], right[i]);
        }
        
        return result;
    }
}