【LeetCode】栈 stack（共40题）

【20】Valid Parentheses (2018年11月28日，复习， ko)

给了一个字符串判断是不是合法的括号配对。

题解：直接stack

 class Solution {
 public:
     bool isValid(string s) {
         set<char> st{'(', '[', '{'};
         map<char, char> mp{{'(', ')'}, {'{', '}'}, {'[', ']'}};
         stack<char> stk;
         for (auto c : s) {
             if (st.find(c) != st.end()) {
                 stk.push(c);
             } else {
                 if (stk.empty()) { return false; }
                 char t = stk.top();
                 if (mp[t] == c) {
                     stk.pop();
                 } else {
                     return false;
                 }
             }
         }
         return stk.empty();
     }
 };

【42】Trapping Rain Water （2018年11月29日，需要复习，单调栈的思想）

给了一个直方图，问里面能存多少雨水。

题解：单调栈的思想。对于数组中的每一个元素，如果栈顶元素比它小，那么当前栈顶如果左边还有柱子能围住栈顶的话，栈顶肯定有雨水。

 //依旧还是单调栈的思想，一个元素如果比栈顶元素大，那么它就比栈顶元素强，强的话凭啥让栈顶元素呆在栈里面？
 class Solution {
 public:
     int trap(vector<int>& height) {
         const int n = height.size();
         int ret = ;
         stack<int> stk;
         for (int cur = ; cur < n; ++cur) {
             while (!stk.empty() && height[stk.top()] < height[cur]) {
                 int t = stk.top(); stk.pop();
                 if (stk.empty()) {break;}
                 int leftIdx = stk.top();
                 int dis = cur - leftIdx - , h = min(height[leftIdx], height[cur]) - height[t];
                 ret += dis * h;
             }
             stk.push(cur);
         }
         return ret;
     }
 };

【71】Simplify Path （2018年11月29日，复习，ko）

给了一个字符串代表 linux 的文件目录，化简这个字符串。 "." 代表当前目录， ".." 代表上一层目录。

For example,
path = "/home/", => "/home"
path = "/a/./b/../../c/", => "/c"
path = "/a/../../b/../c//.//", => "/c"
path = "/a//b////c/d//././/..", => "/a/b/c"

题解：分解字符串，然后用栈直接存。遇到 '.' 忽略， 遇到 '..' 弹出，其他往里push就行。

 class Solution {
 public:
     string simplifyPath(string path) {
         const int n = path.size();
         stringstream ss;
         ss << path;
         string word;
         stack<string> stk;
         while (getline(ss, word, '/')) {
             if (word == ".") {
                 continue;
             } else if (word == "..") {
                 if (!stk.empty()) { stk.pop(); }
             } else if (!word.empty()) {
                 stk.push(word);
             }
         }
         int size = stk.size();
         string ans;
         for (int i = ; i < size; ++i) {
             ans = "/" + stk.top() + ans;
             stk.pop();
         }
         if (size == ) {
             ans = "/";
         }
         return ans;
     }
 };

【84】Largest Rectangle in Histogram （2018年11月29日，单调栈，需要复习）

【85】Maximal Rectangle （2018年11月29日，单调栈，需要复习）

【94】Binary Tree Inorder Traversal (2018年11月29日，树的题目先不做)

【103】Binary Tree Zigzag Level Order Traversal (2018年11月29日，树的题目先不做)

【144】Binary Tree Preorder Traversal (2018年11月29日，树的题目先不做)

【145】Binary Tree Postorder Traversal (2018年11月29日，树的题目先不做)

【150】Evaluate Reverse Polish Notation （2018年11月29日，复习，ko）

逆波兰表达式求值。题目保证输入合法。

Example 1:
Input: ["2", "1", "+", "3", "*"]
Output: 9

Example 2:
Input: ["10", "6", "9", "3", "+", "-11", "*", "/", "*", "17", "+", "5", "+"]
Output: 22
Explanation:
  ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

题解：用栈实现，注意 - 和 / 的时候的顺序。

 class Solution {
 public:
     int evalRPN(vector<string>& tokens) {
         stack<int> stk;
         for (auto s : tokens) {
             if (s == "+") {
                 if (stk.size() >= ) {
                     int a = stk.top(); stk.pop();
                     int b = stk.top(); stk.pop();
                     stk.push(a+b);
                 }
             } else if (s == "-") {
                 if (stk.size() >= ) {
                     int a = stk.top(); stk.pop();
                     int b = stk.top(); stk.pop();
                     stk.push(b-a);
                 }
             } else if (s == "*") {
                 if (stk.size() >= ) {
                     int a = stk.top(); stk.pop();
                     int b = stk.top(); stk.pop();
                     stk.push(a*b);
                 }
             } else if (s == "/") {
                 if (stk.size() >= ) {
                     int a = stk.top(); stk.pop();
                     int b = stk.top(); stk.pop();
                     stk.push(b/a);
                 }
             } else {
                 stk.push(stoi(s));
             }
         }
         return stk.top();
     }
 };

【155】Min Stack （2018年11月29日，水题，ko）

实现一个特殊的栈，在实现栈的基本功能的基础上，再实现返回栈中最小元素的操作。

题解：两个栈实现，一个栈是记录真实数据，另外一个辅助栈记录最小值

 class MinStack {
 public:
     /** initialize your data structure here. */
     MinStack() {

     }

     void push(int x) {
         stk.push(x);
         if (!help.empty()) {
             help.push(min(help.top(), x));
         } else {
             help.push(x);
         }
     }

     void pop() {
         stk.pop();
         help.pop();
     }

     int top() {
         return stk.top();
     }

     int getMin() {
         return help.top();
     }
     stack<int> stk, help;
 };

 /**
  * Your MinStack object will be instantiated and called as such:
  * MinStack obj = new MinStack();
  * obj.push(x);
  * obj.pop();
  * int param_3 = obj.top();
  * int param_4 = obj.getMin();
  */

【173】Binary Search Tree Iterator (2018年11月29日，树的题目先不做)

【224】Basic Calculator (2018年11月16日，算法群)

给了一个字符串算式，里面有数字，有“+”， “-” , “ ” , 和 “(” , ")"。问算式最后结果是多少，返回int。

题解：这题两年前我好像抄的答案，今天自己写了一遍，我写的有点长，我是用了 两个栈，一个存数字，一个存符号。符号栈里面栈顶如果遇到 “+”， “-”，就把两个数搞出来作处理。如果遇到 “(” 就 push 到栈里面，如果遇到 ")"就把上一个 “(” 前面的所有符号和数字都弹出作处理。写的很长，debug了也有一会儿。

 class Solution {
 public:
     int calculate(string s) {
         stack<int> stkNum;
         stack<char> stkPunc;
         const int n = s.size();
         int res = ;
         string temp = "";
         for (int i = ; i < n; ++i) {
             char c = s[i];
             if (isdigit(c)) {
                 temp += string(, c);
             } else {
                 if (!temp.empty()) {
                     stkNum.push(stoi(temp));
                     temp = "";
                 }
                 if (c == ' ') { continue; }
                 if (c == '(') { stkPunc.push(c); }
                 while (stkNum.size() >=  && !stkPunc.empty() && stkPunc.top() != '(') {
                     int a = stkNum.top(); stkNum.pop();
                     int b = stkNum.top(); stkNum.pop();
                     char p = stkPunc.top(); stkPunc.pop();
                     int t = ;
                     if (p == '+') { t = a + b; }
                     if (p == '-') { t = b - a; }
                     stkNum.push(t);
                 }
                 if (c == '+' || c == '-') { stkPunc.push(c); }
                 if (c == ')') {
                     while (!stkPunc.empty() && stkPunc.top() != '(' && stkNum.size() >= ) {
                         int a = stkNum.top(); stkNum.pop();
                         int b = stkNum.top(); stkNum.pop();
                         char p = stkPunc.top(); stkPunc.pop();
                         int t = ;
                         if (p == '+') { t = a + b; }
                         if (p == '-') { t = b - a; }
                         stkNum.push(t);
                     }
                     if (!stkPunc.empty() && stkPunc.top() == '(') {
                         stkPunc.pop();
                     }
                 }
             }
         }
         if (!temp.empty()) {
             stkNum.push(stoi(temp));
             temp = "";
         }
         while (stkNum.size() >=  && !stkPunc.empty()) {
             int a = stkNum.top(); stkNum.pop();
             int b = stkNum.top(); stkNum.pop();
             char p = stkPunc.top(); stkPunc.pop();
             int t = ;
             if (p == '+') { t = a + b; }
             if (p == '-') { t = b - a; }
             stkNum.push(t);
         }
         res = stkNum.top();
         return res;
     }
     /*
     void printstk (stack<int> s1, stack<char> s2) {
         printf("stkNum : ");
         while (!s1.empty()) {
             printf("%d ", s1.top());
             s1.pop();
         }
         printf("\n");
         printf("stkPunc : ");
         while (!s2.empty()) {
             printf("%c ", s2.top());
             s2.pop();
         }
         printf("\n");
     }
     */
 };

然后看了群里小伙伴们的解法基本都差不多，就是比较标准比较短的解法。我们用一个栈，存数字 也存符号。符号如果是 “+”, 就用数字 1 入栈，符号如果是 “-”，就用数字 -1 入栈。每次遇到一个新的符号，“+”，“-”，或者 “(“，”)“，我们就把原来的数字和符号处理掉再用新的符号覆盖原来的变量。

 class Solution {
 public:
     int calculate(string s) {
         stack<int> stk;
         string temp = "";
         int sign = , res = , num = ;
         for (auto c : s) {
             if (isdigit(c)) {
                 temp += string(, c);
             } else {
                 if (c == ' ') { continue; }
                 num = temp.empty() ?  : stoi(temp);
                 temp = "";
                 if (c == '+' || c == '-') {
                     res += sign * num;
                     sign = c == '+' ?  : -;
                     num = ;
                 }
                 if (c == '(') {
                     stk.push(res);
                     stk.push(sign);
                     res = , sign = , num = ;
                 }
                 if (c == ')') {
                     res += sign * num;
                     sign = stk.top(), stk.pop();
                     num = stk.top(), stk.pop();
                     res = sign * res + num;
                     num = , sign = ;
                 }
             }
         }
         if (!temp.empty()) {
             res += sign * stoi(temp);
         }
         return res;
     }
 };

【225】Implement Stack using Queues （2018年11月29日，复习，ko）

用两个队列实现一个栈。

题解：还是思考了一下的。

 class MyStack {
 public:
     /** Initialize your data structure here. */
     MyStack() {

     }

     /** Push element x onto stack. */
     void push(int x) {
         que1.push(x);
     }

     /** Removes the element on top of the stack and returns that element. */
     int pop() {
         if (que1.empty()) { swap(que1, que2); }
         int size = que1.size();
         for (int i = ; i < size - ; ++i) {
             que2.push(que1.front());
             que1.pop();
         }
         int t = que1.front(); que1.pop();
         return t;
     }

     /** Get the top element. */
     int top() {
         if (que1.empty()) { swap(que1, que2); }
         int size = que1.size();
         for (int i = ; i < size - ; ++i) {
             que2.push(que1.front());
             que1.pop();
         }
         return que1.front();
     }

     /** Returns whether the stack is empty. */
     bool empty() {
         return que1.empty() && que2.empty();
     }
     queue<int> que1, que2;
 };

 /**
  * Your MyStack object will be instantiated and called as such:
  * MyStack obj = new MyStack();
  * obj.push(x);
  * int param_2 = obj.pop();
  * int param_3 = obj.top();
  * bool param_4 = obj.empty();
  */

【232】Implement Queue using Stacks （2018年11月29日，复习，ko）

用两个队列实现一个栈。

题解：只要把握住一个原则就行。stk2 里面如果有东西，就不要往里倒。

 class MyQueue {
 public:
     /** Initialize your data structure here. */
     MyQueue() {

     }

     /** Push element x to the back of queue. */
     void push(int x) {
         stk1.push(x);
     }

     /** Removes the element from in front of queue and returns that element. */
     int pop() {
         int t = peek();
         stk2.pop();
         return t;
     }

     /** Get the front element. */
     int peek() {
         if (stk2.empty()) {
             int size = stk1.size();
             for (int i = ; i < size; ++i) {
                 stk2.push(stk1.top());
                 stk1.pop();
             }
         }
         return stk2.top();
     }

     /** Returns whether the queue is empty. */
     bool empty() {
         return stk1.empty() && stk2.empty();
     }
     stack<int> stk1, stk2;
 };

 /**
  * Your MyQueue object will be instantiated and called as such:
  * MyQueue obj = new MyQueue();
  * obj.push(x);
  * int param_2 = obj.pop();
  * int param_3 = obj.peek();
  * bool param_4 = obj.empty();
  */

【255】Verify Preorder Sequence in Binary Search Tree （2018年11月29日，树的题目先不做）

【272】Closest Binary Search Tree Value II （2018年11月29日，树的题目先不做）

【316】Remove Duplicate Letters （2018年11月28日，学习单调栈）

给了一个字符串，有重复的字母，要求给这个字符串去重，去重后的字符串需要是解集中字典序最小的，并且需要是原串的子序列。

Given a string which contains only lowercase letters, remove duplicate letters so that every letter appear once and only once. You must make sure your result is the smallest in lexicographical order among all possible results.

Example :
Input: "bcabc"
Output: "abc"
Example :
Input: "cbacdcbc"
Output: "acdb"

题解：一开始不会做，后来看了lintcode上有个人写的注释我就懂了，就是单调栈的思想。对于 S 中的一个字母 c，如果它已经在栈中出现了，就忽略它这次的出现。如果它没在栈中出现，那我们看栈顶，把优先级不如 c 并且以后还会出现的字母弹出去。最后把 c push 进来。https://www.lintcode.com/problem/remove-duplicate-letters/note/150821

 class Solution {
 public:
     string removeDuplicateLetters(string s) {
         vector<int> record(, ), st(, );
         for (auto c : s) {
             record[c-'a']++;
         }
         stack<char> stk;
         for (auto c : s) {
             //如果 c 已经在栈中了，就continue （说明 c 已经找到了最佳位置）
             if (st[c-'a']) {
                 record[c-'a']--;
                 continue;
             }
             //如果栈里面有元素不如当前元素，并且它在record里面还有值（也就是说它在后续字符串中还会出现），那么就把它弹出。
             while (!stk.empty() && stk.top() > c && record[stk.top()-'a'] >= ) {
                 st[stk.top()-'a'] = ;
                 stk.pop();
             }
             stk.push(c);
             record[c-'a']--;
             st[c-'a'] = ;
         }
         int size = stk.size();
         string ret(size, 'a');
         for (int i = size-; i >= ; --i) {
             ret[i] = stk.top();
             stk.pop();
         }
         return ret;
     }
 };

【331】Verify Preorder Serialization of a Binary Tree （2018年11月29日，树的题目先不做）

【341】Flatten Nested List Iterator  （2018年11月29日，第一次做）

给了一个嵌套列表，返回列表中的所有值。

Example 1:
Input: [[1,1],2,[1,1]]
Output: [1,1,2,1,1]
Explanation: By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,1,2,1,1].

Example 2:
Input: [1,[4,[6]]]
Output: [1,4,6]
Explanation: By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,4,6].

题解：我用的递归解的，没用stack。

 /**
  * // This is the interface that allows for creating nested lists.
  * // You should not implement it, or speculate about its implementation
  * class NestedInteger {
  *   public:
  *     // Return true if this NestedInteger holds a single integer, rather than a nested list.
  *     bool isInteger() const;
  *
  *     // Return the single integer that this NestedInteger holds, if it holds a single integer
  *     // The result is undefined if this NestedInteger holds a nested list
  *     int getInteger() const;
  *
  *     // Return the nested list that this NestedInteger holds, if it holds a nested list
  *     // The result is undefined if this NestedInteger holds a single integer
  *     const vector<NestedInteger> &getList() const;
  * };
  */
 class NestedIterator {
 public:
     NestedIterator(vector<NestedInteger> &nestedList) {
         nums = getNums(nestedList);
         idx = ;
         size = nums.size();
     }

     int next() {
         return nums[idx++];
     }

     bool hasNext() {
         return idx < size;
     }
     vector<int> getNums(vector<NestedInteger>& nestedList) {
         vector<int> ret;
         for (auto ele : nestedList) {
             if (ele.isInteger()) {
                 ret.push_back(ele.getInteger());
             } else {
                 vector<int> t = getNums(ele.getList());
                 for (auto element : t) {
                     ret.push_back(element);
                 }
             }
         }
         return ret;
     }
     vector<int> nums;
     int idx = , size = ;
 };

 /**
  * Your NestedIterator object will be instantiated and called as such:
  * NestedIterator i(nestedList);
  * while (i.hasNext()) cout << i.next();
  */

【385】Mini Parser

【394】Decode String

【402】Remove K Digits

【439】Ternary Expression Parser (2019年2月11日)

这是一个系列的题：

341 Flatten Nested List Iterator

385 Mini Parser

439 Ternary Expression Parser

本题是给了一个字符串作为三元表达式，求解析结果。

Input: "T?T?F:5:3"
Output: "F"

题解：看起来很难，其实还好，如果出现了连续五个字符 x?a:b 就说明这个该解析了。该解析的时候就把前面的这个整个丢进栈里面。我们用第二个字符是不是 ? 看判断前面的字符是否应该丢进栈里。

需要最早解析的字符串，其实是已经形成标准型a?X:Y的这五个连续字符。所以在第一次出现这五个连续字符之前的字符，都可以不断存进一个栈里供后续处理。

 class Solution {
 public:
     string parseTernary(string expression) {
         const int n = expression.size();
         stack<string> stk;
         string cur = "";
         for (int i = ; i < n; ++i) {
             if (i +  < n && expression[i+] == '?') {
                 stk.push(cur);
                 cur = string(, expression[i]);
             } else {
                 cur += string(, expression[i]);
                 while (cur.size() == ) {
                     cur = getRes(cur);
                     if (stk.empty()) {continue;}
                     cur = stk.top() + cur;
                     stk.pop();
                 }
             }
         }
         return cur;
     }
     string getRes(string str) {
         if (str[] == 'T') {
             return string(, str[]);
         }
         return string(, str[]);
     }
 };

【456】132 Pattern

【496】Next Greater Element I （2018年11月29日，第一次做， 裸的单调栈）

给了两个数组 nums1 和 nums2， nums1 是 nums2 的子集。对于nums1中的每个元素 target，找到nums2中的对应元素的右边的第一个比 target 大的值。

题解：我先用单调栈把 nums2 的每个元素的右边第一个比它大的值求出来，存在 map 里面。然后遍历 nums1， 在 map 里面找。

 class Solution {
 public:
     vector<int> nextGreaterElement(vector<int>& findNums, vector<int>& nums) {
         unordered_map<int, int> mp;
         stack<int> stk;
         for (auto n : nums) {
             while (!stk.empty() && stk.top() < n) {
                 mp[stk.top()] = n;
                 stk.pop();
             }
             stk.push(n);
         }
         const int n = findNums.size();
         vector<int> ret(n, -);
         for (int i = ; i < n; ++i) {
             if (mp.find(findNums[i]) == mp.end()) {continue;}
             ret[i] = mp[findNums[i]];
         }
         return ret;
     }
 };

此外，本题应该可以更快，我只 beats 了 35%。

【503】Next Greater Element II

【591】Tag Validator

【636】Exclusive Time of Functions （2018年12月31日，昨天算法群mock的题目， 需要复习）

给了一个单个CPU任务调度的日志，形式为：function_id:start_or_end:timestamp，共有 N 个function， K 条日志，返回每个function调用的时间。一旦下一个任务开始，当前执行的任务就会被中断。

For example, "0:start:0" means function 0 starts from the very beginning of time 0. "0:end:0" means function 0 ends to the very end of time 0. 这句话要好好体会。解释了为啥碰到 end 要加一，碰到 start 不用加一。

Input:
n = 2
logs =
["0:start:0",
 "1:start:2",
 "1:end:5",
 "0:end:6"]
Output:[3, 4]
Explanation:
Function 0 starts at time 0, then it executes 2 units of time and reaches the end of time 1.
Now function 0 calls function 1, function 1 starts at time 2, executes 4 units of time and end at time 5.
Function 0 is running again at time 6, and also end at the time 6, thus executes 1 unit of time.
So function 0 totally execute 2 + 1 = 3 units of time, and function 1 totally execute 4 units of time.

题解：我们用一个栈表示当前没有执行完的任务，然后两个变量cur_time，和 prev_time 表示当前日志时间，和前一条日志的时间。（注意前一条日志的时间会根据 start 和 end 决定是不是取当前的cur_time 还是 cur_time + 1）

 class Solution {
 public:
     vector<int> exclusiveTime(int n, vector<string>& logs) {
         vector<int> ret(n, );
         stack<int> stk;
         int prev_time = ;
         for (auto & log : logs) {
             int taskId, cur_time; string op;
             split(log, taskId, op, cur_time);
             if (op == "start") {
                 if (!stk.empty()) {
                     ret[stk.top()] += cur_time - prev_time;
                 }
                 stk.push(taskId);
                 prev_time = cur_time;
             } else {
                 if (!stk.empty()) {
                     ret[stk.top()] += cur_time - prev_time + ;
                     stk.pop();
                 }
                 prev_time = cur_time + ;
             }
         }
         return ret;
     }
     inline void split (const string log, int& taskId, string& op, int& time) {
         vector<string> info();
         stringstream ss(log);
         getline(ss, info[], ':');
         getline(ss, info[], ':');
         getline(ss, info[], ':');
         taskId = stoi(info[]);
         op = info[];
         time = stoi(info[]);
         return;
     }
 };

【682】Baseball Game

【726】Number of Atoms

【735】Asteroid Collision

【739】Daily Temperatures

【770】Basic Calculator IV

【772】Basic Calculator III

【844】Backspace String Compare

【853】Car Fleet (2019年3月11日，google tag)

有N辆车，事先知道了他们的位置和速度，他们都要去target。如果在路上后面的车追上了前面的车，那么不能超过这个车，只能保险杠挨着保险杠用前车的速度继续前进，那么这个叫做一个车队。单辆车也是一个车队，最后需要求的是总共有多少个车队到达终点。

Example 1:
Input: target = 12, position = [10,8,0,5,3], speed = [2,4,1,1,3]
Output: 3
Explanation:
The cars starting at 10 and 8 become a fleet, meeting each other at 12.
The car starting at 0 doesn't catch up to any other car, so it is a fleet by itself.
The cars starting at 5 and 3 become a fleet, meeting each other at 6.
Note that no other cars meet these fleets before the destination, so the answer is 3.

Note:
0 <= N <= 10 ^ 4
0 < target <= 10 ^ 6
0 < speed[i] <= 10 ^ 6
0 <= position[i] < target
All initial positions are different.

题解：本题我们需要解决两个问题：

(1)车的顺序，我们想先把车的先后顺序排好，可以利用当前车辆距离target的距离来排序。

(2)后面的车能不能在到达target之前追上前车。利用每辆车到达终点的剩余开车时间。如果后面一辆车的剩余开车时间小于等于前面那辆车，那么这两车一定可以合并成一个车队。

 class Solution {
 public:
     int carFleet(int target, vector<int>& position, vector<int>& speed) {
         map<int, double> mp;
         const int n = position.size();
         for (int i = ; i < n; ++i) {
             mp[(target-position[i])] = (double)(target-position[i])/speed[i];
         }
         int res = ;
         double curTime = ;
         for (auto& it : mp) {
             if (it.second > curTime) {
                 curTime = it.second;
                 res++;
             }
         }
         return res;
     }
 };

【856】Score of Parentheses

【880】Decoded String at Index

【895】Maximum Frequency Stack