Update

problems/0150.逆波兰表达式求值.md

@@ -0,0 +1,33 @@
+## 题目地址 
+https://leetcode-cn.com/problems/evaluate-reverse-polish-notation/
+
+## 思路 
+
+这道题目相当于是二叉树中的后序遍历，也引申出栈与递归之间在某种程度上是可以转换的！
+
+## C++代码
+
+```
+class Solution {
+public:
+    int evalRPN(vector<string>& tokens) {
+        stack<int> st;
+        for (int i = 0; i < tokens.size(); i++) {
+            if (tokens[i] == "+" || tokens[i] == "-" || tokens[i] == "*" || tokens[i] == "/") {
+                int num1 = st.top();
+                st.pop();
+                int num2 = st.top();
+                st.pop();
+                if (tokens[i] == "+") st.push(num2 + num1);
+                if (tokens[i] == "-") st.push(num2 - num1);
+                if (tokens[i] == "*") st.push(num2 * num1);
+                if (tokens[i] == "/") st.push(num2 / num1);
+            } else {
+                st.push(stoi(tokens[i]));
+            }
+        }
+        return st.top();
+    }
+};
+```
+> 笔者在先后在腾讯和百度从事技术研发多年，利用工作之余重刷leetcode，本文  [GitHub](https://github.com/youngyangyang04/leetcode-master )：https://github.com/youngyangyang04/leetcode-master 已经收录，欢迎star，fork，共同学习，一起进步。

problems/0239.滑动窗口最大值.md

@@ -0,0 +1,46 @@
+## 题目地址 
+https://leetcode-cn.com/problems/sliding-window-maximum/
+
+## 思路
+
+
+## C++代码
+
+```
+class Solution {
+public:
+    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 front() {
+            return que.front();
+        }
+    };
+    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.front());
+        for (int i = k; i < nums.size(); i++) {
+            que.pop(nums[i - k]);
+            que.push(nums[i]);
+            result.push_back(que.front());
+        }
+        return result;
+    }
+};
+```

problems/0347.前K个高频元素.md

@@ -0,0 +1,41 @@
+## 题目地址 
+
+## 思路
+
+
+## C++代码
+```
+class Solution {
+public:
+    class mycomparison {
+    public:
+        bool operator()(const pair<int, int>& lhs, const pair<int, int>& rhs) {
+            return lhs.second < rhs.second;
+        }
+    };
+    // 如何定义priQue
+    // 如何定义cmp
+    // 如何遍历map
+    vector<int> topKFrequent(vector<int>& nums, int k) {
+        unordered_map<int, int> map;
+        for (int i = 0; i < nums.size(); i++) {
+            map[nums[i]]++;
+        }
+        // greater<pair<int, int>> 也可以
+        priority_queue<pair<int, int>, vector<pair<int, int>>, mycomparison> pri_que;
+
+        // 当然可以使用auto
+        for (unordered_map<int, int>::iterator it = map.begin(); it != map.end(); it++) {
+            pri_que.push(*it);
+        }
+        // 一开始就确定空间
+        vector<int> result(k);
+        for (int i = 0; i < k; i++) {
+            result[i] = pri_que.top().first;
+            pri_que.pop();
+        }
+        return result;
+
+    }
+};
+```

problems/0575.分糖果.md

@@ -3,8 +3,9 @@ https://leetcode-cn.com/problems/distribute-candies/
 
 ## 思路 
 
-因为种类是可妹妹先来，所以思路先求出一共有多少种糖果，然后如果糖果种类大于candies的一半了，return candies的一半，否则，就是return 糖果的种类就可以了。
+糖果的种类是可妹妹先来，所以思路先求出一共有多少种类型的糖果，需要注意： 数组中数字的大小也就是糖果的种类取值范围在[负十万和 正十万之间]， 依然可以定义一个数组，通过哈希法求出有多少类型的糖果，那么糖果种类可以是负数 怎么办呢，可以把 定一个 20万大小的数组 ，就可以把糖果的全部类型映射到数组的下表了。
 
+通过哈希法，可以求出了糖果的类型数量，如果糖果种类大于糖果总数的一半了，返回 糖果数量的一半就好，因为妹妹已经得到种类最多的糖果了，否则，就是返回 糖果的种类。
 
 ## 代码
 
@@ -34,4 +35,6 @@ public:
     }
 };
 ```
-> 笔者在先后在腾讯和百度从事技术研发多年，利用工作之余重刷leetcode，本文  [GitHub](https://github.com/youngyangyang04/leetcode-master )：https://github.com/youngyangyang04/leetcode-master 已经收录，欢迎star，fork，共同学习，一起进步。
+
+> 更过算法干货文章持续更新，可以微信搜索「代码随想录」第一时间围观，关注后，回复「Java」「C++」 「python」「简历模板」「数据结构与算法」等等，就可以获得我多年整理的学习资料。
+