239. Sliding Window Maximum （滑动窗口最大值， 大根堆or 单调队列）

You are given an array of integers 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 1:

Input: nums = [1,3,-1,-3,5,3,6,7], 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

 法1：

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> res;
        priority_queue<pair<int, int>> q;
        for(int i = 0; i < k;++i) {
            q.push({nums[i],i});
        }
        res.push_back(q.top().first);

        for(int i = k;i < nums.size();++i) {
            q.push({nums[i],i});
            while(q.top().second + k <= i) {
                q.pop();
            }
            res.push_back(q.top().first);
        }
        return res;
    }
};

法二：

https://labuladong.gitbook.io/algo/mu-lu-ye-1/mu-lu-ye-2/dan-tiao-dui-lie

首先，明确一个概念，单调队列是在队列中所有的元素都是单调的，要么单调增，要么单调减，新增元素时到队尾，此时队列不符合单调性就将队尾元素出队，直到队列单调或空。

class MonotonicQueue {
private:
    deque<int> data;
public:
    void push(int n) {
        while (!data.empty() && data.back() < n) 
            data.pop_back();
        data.push_back(n);
    }
    
    int max() { return data.front(); }
    
    void pop(int n) {
        if (!data.empty() && data.front() == n)
            data.pop_front();
    }
};

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
    MonotonicQueue window;
    vector<int> res;
    for (int i = 0; i < nums.size(); i++) {
        if (i < k - 1) { //先填满窗口的前 k - 1
            window.push(nums[i]);
        } else { // 窗口向前滑动
            window.push(nums[i]);
            res.push_back(window.max());
            window.pop(nums[i - k + 1]);
        }
    }
    return res;
    }
};

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
    deque<int> q;
    vector<int> res;
    for (int i = 0; i < nums.size(); i++) {
        // push
        while(!q.empty()&& q.back() < nums[i]) {
            q.pop_back();
        }
        q.push_back(nums[i]);
        if (i >= k - 1) { //前k - 1 已经填满
            res.push_back(q.front());
            // pop
            if(!q.empty() && nums[i - k + 1]== q.front()) {
                q.pop_front();
            }
        }
    }
    return res;
    }
};