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

150.逆波兰表达式求值

要点：确实是没做过的话很难想到解题思路，理解逆波兰表达式是什么，计算机是如何计算数学表达式的

方法：

1. 遍历，找+-*/ 四个符号

2. 碰到符号，就把栈顶的两个元素弹出计算结果

3. 将计算出的结果push入栈

class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<long long> st;
        for (string s : tokens) {
            if (s == "+" || s == "-" || s == "*" || s == "/") {
                long long num1 = st.top();
                st.pop();
                long long num2 = st.top();
                st.pop();
                if (s == "+") st.push(num2 + num1);
                if (s == "-") st.push(num2 - num1);
                if (s == "*") st.push(num2 * num1);
                if (s == "/") st.push(num2 / num1);
            } else {
                st.push(stoll(s));
            }
        }
        long long result = st.top();
        return result;
    }
};

239.滑动窗口最大值

要点：好难。关键点在于实现一个单调递减的队列，这样获取滑动窗口里的最大值，就不用暴力遍历取最大，只用取队列第一个元素就可以了

方法：

1. 自定义单调递减的队列结构，包含3个方法

        1.1 弹出队首最大元素

        1.2 push元素，如果push的元素比当前队尾的大，弹出队尾，再push，保证push的元素前面只有比它大的，没有比它小的

        1.3 找最大，就是返回队首元素

2. 使用自定义结构，push k个元素进去

3. 先把初始化窗口的最大值放进result里

4. 开始遍历第k+1个元素，从这个元素开始，每个元素都要经历pop push getMax的操作，pop保证自定义队列中最多只有k个元素，push保证自定义队列的队首是当前滑动窗口的最大值

class Solution {
private:
    class MyQueue {
    public:
        deque<int> que;
        void pop(int value) {
            if (!que.empty() && value == que.front()) {
                que.pop_front();
            }
        }
        void push(int value) {
            while (!que.empty() && value > que.back()) {
                que.pop_back();
            }
            que.push_back(value);
        }
        int getMax() { return que.front(); }
    };

    public : vector<int>
             maxSlidingWindow(vector<int>& nums, int k) {
        MyQueue que;
        vector<int> result;
        for (int i = 0; i < k; i++) {
            que.push(nums[i]);
        }
        result.push_back(que.getMax());
        for (int i = k; i < nums.size(); i++) {
            que.pop(nums[i - k]);
            que.push(nums[i]);
            result.push_back(que.getMax());
        }
        return result;
    }
};

347.前 K 个高频元素

要点：统计完所有元素出现的频率后，如何给频率排序，以达到题目要求的时间复杂度才是要点。堆排序出现得有点突然，这里没看懂，等看完树之后再回来重温

方法：

1. map+遍历，统计元素出现的频率

2. 给map按value排序，取前k个pair的key

class Solution {
public:
    class myComparison {
    public:
        bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs) {
            return lhs.second > rhs.second;
        }
    };

    vector<int> topKFrequent(vector<int>& nums, int k) {
        unordered_map<int, int> map;
        for (int i = 0; i < nums.size(); i++) {
            map[nums[i]]++;
        }
        priority_queue<pair<int, int>, vector<pair<int, int>>, myComparison>
            pri_que;
        for (unordered_map<int, int>::iterator it = map.begin();
             it != map.end(); it++) {
            pri_que.push(*it);
            if (pri_que.size() > k) {
                pri_que.pop();
            }
        }
        vector<int> result(k);
        for (int i = k - 1; i >= 0; i--) {
            result[i] = pri_que.top().first;
            pri_que.pop();
        }
        return result;
    }
};