代码随想录算法训练营第十三天 | 239.滑动窗口最大值、347.前K个高频元素

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]

提示：

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

二、解题思路

        一开始用的是优先队列去做，但优先队列有个问题是，当滑动窗口内有两个一样的值，而且这两个值都不是最大的时候，他们在队列里不是最前的值，但都被挤到后面排队了，弹不出去了。

可能会想用一个大顶堆（优先级队列）来存放这个窗口里的k个数字，这样就可以知道最大的最大值是多少了， 但是问题是这个窗口是移动的，而大顶堆每次只能弹出最大值，我们无法移除其他数值，这样就造成大顶堆维护的不是滑动窗口里面的数值了。所以不能用大顶堆。

        看了代码随想录的解题方式后，他是这样的：

队列里的元素一定是要排序的，而且要最大值放在出队口，要不然怎么知道最大值呢。

但如果把窗口里的元素都放进队列里，窗口移动的时候，队列需要弹出元素。

那么问题来了，已经排序之后的队列 怎么能把窗口要移除的元素（这个元素可不一定是最大值）弹出呢。

大家此时应该陷入深思.....

其实队列没有必要维护窗口里的所有元素，只需要维护有可能成为窗口里最大值的元素就可以了，同时保证队列里的元素数值是由大到小的。

那么这个维护元素单调递减的队列就叫做单调队列，即单调递减或单调递增的队列。C++中没有直接支持单调队列，需要我们自己来实现一个单调队列

不要以为实现的单调队列就是 对窗口里面的数进行排序，如果排序的话，那和优先级队列又有什么区别了呢。

来看一下单调队列如何维护队列里的元素。

动画如下：

对于窗口里的元素{2, 3, 5, 1 ,4}，单调队列里只维护{5, 4} 就够了，保持单调队列里单调递减，此时队列出口元素就是窗口里最大元素。

此时大家应该怀疑单调队列里维护着{5, 4} 怎么配合窗口进行滑动呢？

设计单调队列的时候，pop，和push操作要保持如下规则：

1. pop(value)：如果窗口移除的元素value等于单调队列的出口元素，那么队列弹出元素，否则不用任何操作
2. push(value)：如果push的元素value大于入口元素的数值，那么就将队列入口的元素弹出，直到push元素的数值小于等于队列入口元素的数值为止

保持如上规则，每次窗口移动的时候，只要问que.front()就可以返回当前窗口的最大值。

        这个方法跟优先队列不一样的是，他的单调不是对全部数字排序，而是遇到后面一个数字a时候，把在这个数前比他小的都弹走，因为在滑动窗口开始到结束这个范围内，只要数字a在，那么窗口里面比他小的数字就都不会被要求记录，而是随着滑动窗口过了就不存在了。

        如果没有比他更大的数，就会把窗口里（队列里的数全部弹出来），但如果有比a大的数字A的话，就不将最大的弹出来，而是把a放进去，因为当前面那个最大的出了范围后，a还在窗口里，这时候a就有可能变成最大的，而A-a之间的数字在a被过掉前就会被过掉，但存在窗口内的时候都会跟a在一个窗口里，所以不需要记录，弹出去就好。

        当要弹出去的数字等于目前最大的数字（也就是队列最前端的数字），比如假设是A，，那么证明A前面的数字都在不知不觉中被遍历过掉了，轮到A要出滑动窗口了，就把A弹出去，A后面一个数字不是a，这个队列依然不会变，A的下标+1到窗口范围内的最大值依然是a，除非a后那个数字b比a大，那么在b进来的时候就会把a弹出去了，那么A的下标+1到窗口范围内的最大值依然是队列内最前面的数字，只要要过掉的数字不是队列内最前面的数字，都不用动这个队列。

        但如果用优先队列的话，就弹不掉A-a中间的数。

三、解题代码

class Solution {
public:
    //按照我们的想法利用底层容器deque实现的队列数据结构
    class MyQue{
    public:
        void pop(const int value){
            if(!DQue.empty() && DQue.front() == value){
                DQue.pop_front();
            }
        }

        void push(const int value){
            while (!DQue.empty() && value > DQue.back()) {
                DQue.pop_back();//后面的弹出去
            }
            DQue.push_back(value);
        }

        int front(){
            return DQue.front();
        }

    private:
        deque<int> DQue;
    };

    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> ans;
        MyQue Que;
        for(int i = 0; i < k; i++){
            Que.push(nums[i]);
        }
        ans.push_back(Que.front());
        for(int i = k; i < nums.size(); i++){
            Que.pop(nums[i-k]);
            Que.push(nums[i]);
            ans.push_back(Que.front());
        }
        return ans;
    }
};

347.前K个高频元素

一、题目详情

给你一个整数数组 nums 和一个整数 k ，请你返回其中出现频率前 k 高的元素。你可以按 任意顺序 返回答案。

示例 1:

输入: nums = [1,1,1,2,2,3], k = 2
输出: [1,2]

示例 2:

输入: nums = [1], k = 1
输出: [1]

提示：

• 1 <= nums.length <= 105
• k 的取值范围是 [1, 数组中不相同的元素的个数]
• 题目数据保证答案唯一，换句话说，数组中前 k 个高频元素的集合是唯一的

进阶：你所设计算法的时间复杂度 必须 优于 O(n log n) ，其中 n 是数组大小。

二、解题思路

        第一反应就是哈希+优先队列。因为要计算频率，所以就用unordered_map来存储元素及其出现的次数，然后再根据元素出现的次数，也就是map的value进行排序。

        一开始想用的最大堆，就是遍历完后依次弹出K个值。但最大堆里面除了顶端是最大值，其他是以二叉树结构存储的，弹出一个最大堆后又要维护一遍得到剩下的最大值，也就是进来维护n次，弹出去维护k次。看完题解后，发现这个就很妙：

而且使用大顶堆就要把所有元素都进行排序，那能不能只排序k个元素呢？

所以我们要用小顶堆，因为要统计最大前k个元素，只有小顶堆每次将最小的元素弹出，最后小顶堆里积累的才是前k个最大元素。

        这样就可以进来n次，弹出n-k次，减少了冗余操作。

三、解题代码

class Solution {
    class mycomparison {
    public:
        bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs) {
            return lhs.second > rhs.second;
        }
    };
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int,int> Map;
        vector<int> ans(k);

        for(auto& key : nums){
            Map[key]++;
        }

        priority_queue<pair<int, int>, vector<pair<int, int>>, mycomparison> pri_que;

        // 用固定大小为k的小顶堆，扫面所有频率的数值
        for (unordered_map<int, int>::iterator it = Map.begin(); it != Map.end(); it++) {
            pri_que.push(*it);
            if (pri_que.size() > k) { //如果堆的大小大于了K，则队列弹出
                pri_que.pop();
            }
        }

        for (int i = k - 1; i >= 0; i--) {
            ans[i] = pri_que.top().first;
            pri_que.pop();
        }
        return ans;
    }
};