LeetCode每日一题--239. 滑动窗口最大值（优先队列 单调队列）

题目：跳转至 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 <= 10⁵
• -10⁴ <= nums[i] <= 10⁴
• 1 <= k <= nums.length

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {

    }
};

思路：
题目很好理解，返回滑动窗口中的最大值，最暴力最蠢的方法是可以直接枚举各窗口内的最大值，但铁定超时。

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int len=nums.size();
        if(k==1)
            return nums; 
        vector<int> res(len-k+1);
        for(int i=0;i<len-k+1;++i){
            vector<int> tmp(nums.begin()+i,nums.begin()+i+k);
            int sub=findsubmax(tmp);
            res[i]=nums[sub+i];
        }
        return res;
    }
    int findsubmax(vector<int>& nums){  //返回最大值的下标
        int submax=0;
        for(int i=0;i<nums.size();++i){
            if(nums[i]>=nums[submax])
                submax=i;
        }
        return submax;
    }
};

优化思路也很容易想到，求出一个滑动窗口内的最大值后，暂且保留他，直接和下一个进入窗口的值做比较，那问题又来了，如果最大值正好在最左边要被删除，岂不是又要重排。话一套一套的，实施起来就黔驴技穷，好好学习.jpg

方法一：优先队列
用优先队列维护滑动窗口中的最大值，同时记录下标。已知初始完第一个滑动窗口后每次新放入滑动窗口的数的下标值为 i（i>k），那么优先队列中下标值小于等于 i-k 的必然不在当前滑动窗口内。

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int n=nums.size();
        priority_queue<pair<int,int>> q;  //存储nums值，以及值的下标
        for(int i=0;i<k;++i)  //存储第一个滑动窗口内的值进入优先队列
            q.emplace(nums[i],i);
        vector<int> ans={q.top().first};  //把第一个滑动窗口内的最大值存入结果
        for(int i=k;i<n;++i){  //每次向右滑动一位，将值存入优先队列
            q.emplace(nums[i],i);
            while(q.top().second<=i-k)  //1127531保证输出的最大值都是在当前滑动窗口中的值
                q.pop();
            ans.push_back(q.top().first);
        }
        return ans;
    }
};

方法二：单调队列
k为3，滑动窗口此时对应 [-1,3,5]：

    1 3 [-1 -3 5] 3 6 7

按方法一解答，此时优先队列 q 存储如下：

    (5,4)   (3,1)   (1,0)   (-1,2)   (-3,3)

可以发现，第一次滑动窗口中的 [1 3 -1]，1 小于 3 且在其左侧，在优先队列中，3 仍在滑动窗口中时始终大于 1，当 3 不在当前滑动窗口中时，1 也定不在其中，所以 1 始终不会被使用到。所以前三个滑动窗口优化后的优先队列存储如下：

    (3,1)   (1,0)   (-1,2)
    (3,1)   (1,0)   (-1,2)   (-3,3)
    (5,4)   (3,1)   (1,0)   (-1,2)   (-3,3)

所以，如果当前滑动窗口有两个下标 i，j（i<j）且 nums[i]<=nums[j]，我们可以将 nums[i] 永久排除，并且剩余存储一定是随着 nums 下标逐渐增大，对应的数值呈单调递减状态，单调性就出来了。

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int n=nums.size();
        deque<int> q;  //双端队列存储nums下标，因为在队头队尾进行操作所以用双端
        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;
    }
};

方法三…偷个懒下次遇到再看！