Day11 150. 逆波兰表达式求值 239. 滑动窗口最大值 347.前 K 个高频元素

150. 逆波兰表达式求值 - 力扣（LeetCode）

给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。

请你计算该表达式。返回一个表示表达式值的整数。

注意：

• 有效的算符为 '+'、'-'、'*' 和 '/' 。
• 每个操作数（运算对象）都可以是一个整数或者另一个表达式。
• 两个整数之间的除法总是 向零截断 。
• 表达式中不含除零运算。
• 输入是一个根据逆波兰表示法表示的算术表达式。
• 答案及所有中间计算结果可以用 32 位 整数表示。

规则是先输入两个数，再输入运算符。将运算的结果作为后续运算的数。

还是应该想到栈，如果是数，就入栈，如果遇到操作符+``-``*``/，就取出栈顶的两个元素，计算后再入栈，等待再次被取出(如果是最后一次运算，就是最终结果)

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<long long> st;
        long long ele1;
        long long ele2;
        for(int i = 0;i<tokens.size();i++){
            if(tokens[i]=="+"||tokens[i]=="-"||tokens[i]=="*"||tokens[i]=="/"){
                ele1 = st.top();
                st.pop();
                ele2 = st.top();
                st.pop();
                //取出前两个数
                if(tokens[i]=="+") st.push(ele2+ele1);
                if(tokens[i]=="-") st.push(ele2-ele1);
                if(tokens[i]=="*") st.push(ele2*ele1);
                if(tokens[i]=="/") st.push(ele2/ele1);
            }
            else st.push(stoll(tokens[i]));  //字符串转换为long long 入栈
        }
        return st.top();
    }
};

239. 滑动窗口最大值 - 力扣（LeetCode）

给你一个整数数组 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

单调队列

只维护可能是最大值的元素

每次push的元素一定会入队尾，不论多么小，只要后面的比他更小，等比它大的都移出窗口就可能成为窗口内最大值

每次push，该元素已经进入窗口，如果前面有更小的元素，它们永远不可能成为最大值，从队列后端移出，等所有比此次push的元素小的元素移出，再入队

每次pop，我们都知道要处理的值，就是数组的某一个元素。如果队首不是这个元素，说明在之前的push操作就被弹出，无需再操作。如果队首是这个元素，那就删除。为什么一定在队首？因为任何元素在移出的前一个时刻，要么是当前最大值留在队首(队内元素=k)，要么不可能是最大值被弹出(队内元素<k)。该元素不可能在未被移出的情况下在队内的其他位置；反之，如果在，该元素也不该在下一个时刻移出。

class Solution {

private:
    class MonotonicQueue{
    public:
        //用双端队列实现
        deque<int> q;
        void push(int val){
            //由于是单调队列，push之前会把之前比自己小的都删除
            while(!q.empty()&&q.back()<val){
                q.pop_back();
            }
            //此时，队列末尾元素≥val，满足单调
            q.push_back(val);
        }
        void pop(int val){
            if(!q.empty()&&val==q.front()){
                q.pop_front();//只有队首元素==指定删除的值，才会删除
            }
            //队首元素≠指定删除的值，是因为在push时就被删除，啥也不干就行
        }
        int get_max(){
            return q.front();
        }
    };

public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        vector<int> ans;
        MonotonicQueue q;
        //前k个元素加入窗口，将最大值加入结果数组
        for(int i = 0 ; i < k ; i++){
            q.push(nums[i]);
        }
        ans.push_back(q.get_max());
        //移动窗口
        int size = nums.size();
        for(size_t i = k; i < size; i++){
            q.pop(nums[i-k]);  //头移出窗口
            q.push(nums[i]);   //下一个移入窗口
            ans.push_back(q.get_max());
        }
        return ans;
    }
};

暴力

第一反应，用队列维护滑动窗口，每次都对窗口内的元素取最大值，并记录在数组，也就是暴力法。时间复杂度为$O(n·k)$，思路很简单，但果然会超时。暴力法代码如下

class Solution {
public:
    vector<int> maxSlidingWindow(vector<int>& nums, int k) {
        int size = nums.size();
        //vector<int> ans(size-(k-1));
        vector<int> ans;
        int right = k-1;
        queue<int> window;
        for(int i =0;i<k;i++){
            window.push(nums[i]);
        }

        while(right<size){
            ans.push_back(max_in_window(window));
            right++;
            window.pop();
            if(right<size) window.push(nums[right]);//if是个补丁，防止下边越界，逻辑可以更完善
        }
        return ans;
    }

    int max_in_window(const queue<int>& window){ //获取窗口内最大值
        queue<int> q =window;
        int max = -INT_MAX;
        int ele_in_q;
        while(!q.empty()){
            ele_in_q = q.front();
            max = ele_in_q > max ? ele_in_q : max;
            q.pop();
        }
        return max;
    }
};

347. 前 K 个高频元素 - 力扣（LeetCode）

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

用map记录出现频率，这一点很容易想到，本题知识点在于找到前k个元素并排序

若bool operator()(const pair<int,int>& lhs,const pair<int,int>& rhs)返回1，代表rhs优先级更高

默认是less<_Sequence::value_type>，也就是lhs<rhs返回1，大的优先级高，是大顶堆

我们改成lhs>rhs返回1，小的优先级高，是小顶堆

bool operator()(const pair<int,int>& lhs,const pair<int,int>& rhs){ 
    //返回1，说明rhs优先级更高 
    //默认情况是{less <} ,lhs<rhs返回1，rhs大且优先级大，对应大顶堆 
    if(lhs.second>rhs.second){//rhs出现频率低
    return 1;//优先级高，先上堆顶 
    //小顶堆，出现频率低的先上根节点被弹出 
    } 
    else return 0; 
}

为什么要选小顶堆？因为每次pop都是删除根节点，也就是优先级最高的元素，如果是大顶堆，每当堆中达到k+1个元素，最大的元素处于根节点并被pop，如此往复，最后堆中剩下k个出现频率最低的元素。

反过来，如果是小顶堆，最后堆中剩下k个出现频率最高的元素。

class Solution {
    class mycomparison {
        //返回1说明rhs优先级更高
    public:
        bool operator()(const pair<int,int>& lhs,const pair<int,int>& rhs){
        //返回1，说明rhs优先级更高
        //默认情况是less < ,lhs<rhs返回1，对应大顶堆
            if(lhs.second>rhs.second){//rhs出现频率低
                return 1;//优先级高，先上堆顶
                //小顶堆，出现频率低的先上根节点被弹出
            }
            else return 0;
        }
    };
public:
    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int,int> mp;
        for(int i : nums){
            mp[i]++;
        }
        
        priority_queue<pair<int,int>,vector<pair<int,int>>,mycomparison> pri_q;
        // para1:pair<int,int>
        // para2:vector<pair<int,int>>
        // para3:mycomparison
        for(unordered_map<int,int>::iterator it = mp.begin();it!=mp.end();it++){
            pri_q.push(*it);
            if(pri_q.size()>k){ //k+1个节点
                pri_q.pop();//弹出根节点，保持k个
            }
        }

        vector<int> result(k);
        for (int i = k - 1; i >= 0; i--) {
            result[i] = pri_q.top().first;
            pri_q.pop();
        }
        return result;
    }
};