【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 = 0;
        stack<int> stk;
        for (int cur = 0; 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 - 1, 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 = 0; i < size; ++i) {
            ans = "/" + stk.top() + ans;
            stk.pop();
        }
        if (size == 0) {
            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() >= 2) {
                    int a = stk.top(); stk.pop();
                    int b = stk.top(); stk.pop();
                    stk.push(a+b);
                }
            } else if (s == "-") {
                if (stk.size() >= 2) {
                    int a = stk.top(); stk.pop();
                    int b = stk.top(); stk.pop();
                    stk.push(b-a);
                }
            } else if (s == "*") {
                if (stk.size() >= 2) {
                    int a = stk.top(); stk.pop();
                    int b = stk.top(); stk.pop();
                    stk.push(a*b);
                }
            } else if (s == "/") {
                if (stk.size() >= 2) {
                    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 = 0;
        string temp = "";
        for (int i = 0; i < n; ++i) {
            char c = s[i];
            if (isdigit(c)) {
                temp += string(1, c);
            } else {   
                if (!temp.empty()) {
                    stkNum.push(stoi(temp));
                    temp = "";
                }
                if (c == ' ') { continue; }
                if (c == '(') { stkPunc.push(c); }
                while (stkNum.size() >= 2 && !stkPunc.empty() && stkPunc.top() != '(') {
                    int a = stkNum.top(); stkNum.pop();
                    int b = stkNum.top(); stkNum.pop();
                    char p = stkPunc.top(); stkPunc.pop();
                    int t = 0;
                    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() >= 2) {
                        int a = stkNum.top(); stkNum.pop();
                        int b = stkNum.top(); stkNum.pop();
                        char p = stkPunc.top(); stkPunc.pop();
                        int t = 0;
                        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() >= 2 && !stkPunc.empty()) {
            int a = stkNum.top(); stkNum.pop();
            int b = stkNum.top(); stkNum.pop();
            char p = stkPunc.top(); stkPunc.pop();
            int t = 0;
            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 = 1, res = 0, num = 0;
        for (auto c : s) {
            if (isdigit(c)) {
                temp += string(1, c);
            } else {
                if (c == ' ') { continue; }
                num = temp.empty() ? 0 : stoi(temp);
                temp = "";
                if (c == '+' || c == '-') {
                    res += sign * num;
                    sign = c == '+' ? 1 : -1;
                    num = 0;
                }
                if (c == '(') {
                    stk.push(res);
                    stk.push(sign);
                    res = 0, sign = 1, num = 0;
                }
                if (c == ')') {
                    res += sign * num;
                    sign = stk.top(), stk.pop();
                    num = stk.top(), stk.pop();
                    res = sign * res + num;
                    num = 0, sign = 1;
                }
            }
        }
        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 = 0; i < size - 1; ++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 = 0; i < size - 1; ++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 = 0; 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 1:
Input: "bcabc"
Output: "abc"
Example 2:
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(26, 0), st(26, 0);
        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'] >= 1) {
                st[stk.top()-'a'] = 0;
                stk.pop();
            }
            stk.push(c);
            record[c-'a']--;
            st[c-'a'] = 1;
        }
        int size = stk.size();
        string ret(size, 'a');
        for (int i = size-1; i >= 0; --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 = 0;
        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 = 0, size = 0;
};

/**
 * 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 = 0; i < n; ++i) {
            if (i + 1 < n && expression[i+1] == '?') {
                stk.push(cur);
                cur = string(1, expression[i]);
            } else {
                cur += string(1, expression[i]);
                while (cur.size() == 5) {
                    cur = getRes(cur);
                    if (stk.empty()) {continue;}
                    cur = stk.top() + cur;
                    stk.pop();
                }
            }
        }
        return cur;
    }
    string getRes(string str) {
        if (str[0] == 'T') {
            return string(1, str[2]);
        }
        return string(1, str[4]);
    }
};

  

【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, -1);
        for (int i = 0; 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, 0);
        stack<int> stk;
        int prev_time = 0;
        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 + 1;
                    stk.pop();
                }
                prev_time = cur_time + 1;
            }
        }
        return ret;
    }
    inline void split (const string log, int& taskId, string& op, int& time) {
        vector<string> info(3);
        stringstream ss(log);
        getline(ss, info[0], ':');
        getline(ss, info[1], ':');
        getline(ss, info[2], ':');
        taskId = stoi(info[0]);
        op = info[1];
        time = stoi(info[2]);
        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 = 0; i < n; ++i) {
            mp[(target-position[i])] = (double)(target-position[i])/speed[i];
        }
        int res = 0;
        double curTime = 0;
        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