LeetCode: 239. 滑动窗口最大值

给你一个整数数组 nums，有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。

返回滑动窗口中的最大值。

示例 1：

输入：nums = [1,3,-1,-3,5,3,6,7], k = 3
输出：[3,3,5,5,6,7]
解释：
滑动窗口的位置                最大值
---------------               -----
[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
示例 2：

输入：nums = [1], k = 1
输出：[1]
示例 3：

输入：nums = [1,-1], k = 1
输出：[1,-1]
示例 4：

输入：nums = [9,11], k = 2
输出：[11]
示例 5：

输入：nums = [4,-2], k = 2
输出：[4]
 

提示：

1 <= nums.length <= 105
-104 <= nums[i] <= 104
1 <= k <= nums.length

分析：

       此题最简单的方法是，对于每个滑动窗口而言，遍历其中的每一个元素，找出最大值。这种做法的时间复杂度是O(nk)，但是会超出时间限制。

       于是想到的一种优化方法是利用优先队列，利用大根堆的性质，堆顶总是队列中最大的元素。但此时有一个问题，就是滑动窗口在移动的过程中会删除元素，而优先队列却难以删除某个特定的元素。所以我采用了哈希表来记录当前时刻队列中各元素的数量，对于栈顶的元素，如果在哈希表中的数量为0，那么说明其不在此时的滑动窗口中，那么我们可以将其pop掉，直到当前堆顶的元素在哈希表中有记录。

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int n = nums.size();
        priority_queue<int> pq;
        unordered_map<int, int> m;
        vector<int> ans;
        for(int i = 0; i < n; i++){
            pq.push(nums[i]);
            m[nums[i]]++;
            if(i >= k - 1){
                if(i >= k) m[nums[i - k]]--;
                while(m[pq.top()] == 0) pq.pop();
                ans.push_back(pq.top());
            }
        }
        return ans;
    }
};

       但实际上，此种优化方法的成效有限，其时间复杂度为O(nlogn)。题解里有另一种更理想的优化方法：单调队列。

       如果我们只是在增加元素的同时更新最大值，那是很简单的。但问题是我们同时需要不断地删除元素。那该怎么做呢？

       我们基于这样一个事实：在当前的滑动窗口中，取任意两个坐标分别为i，j（i < j)，如果nums[i] <= nums[j]，我们此窗口中的最大值将一直是nums[j]。换成人话讲，就是说如果一个队伍中有人比你高，那么矮的人在竞选“最高者”时将永无出头之日。所以我们的滑动窗口在吸纳新成员时，如果发现前面的成员比当前成员矮，那么我们可以将这些较矮的同胞们无情地踢出去。这样做的结果是我们会得到一个单调递减的队列。不信？我们可以采用反证法来证明一下：如果说该队列并非单调递减，那么一定存在i，j（i < j），且nums[i] >= nums[j]。而按照我们吸纳成员的“策略”，我们应该已经将i位置的成员移除了，所以这与我们的政策相矛盾。则我们得到的结果的确是一个单调递减的队列。

       这种算法的时间复杂度为O(n)，显然要优于上面的算法。同时因为算法的实现过程需要我们不断地在队首队尾删除元素，此处采用了“双端队列”的数据结构，方便我们操作。

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int n = nums.size();
        deque<int> q;
        for(int i = 0; i < k; i++){
            while(!q.empty() && nums[i] >= nums[q.back()])
                q.pop_back();
            q.push_back(i);
        }
        vector<int> ans = {nums[q.front()]};
        for(int i = k; i < n; i++){
            while(!q.empty() && nums[i] >= nums[q.back()])
                q.pop_back();
            q.push_back(i);
            while(q.front() <= i - k){
                q.pop_front();
            }
            ans.push_back(nums[q.front()]);
        }
        return ans;
    }
};