五月集训（第14天）—栈

目录

• 栈
  • 1. 1441. 用栈操作构建数组
  • 2. 1021. 删除最外层的括号
  • 3. 1700. 无法吃午餐的学生数量
  • 4. 1381. 设计一个支持增量操作的栈

栈

1. 1441. 用栈操作构建数组

    思路：
        利用vector模拟栈操作。每个i都入栈，不是target的出栈

class Solution {
public:
    vector<string> buildArray(vector<int>& target, int n) {
        vector<string> ret;
        int end_num = target.back();
        int index = 0;
        for (int i = 1; i <= n; i++) {
            ret.push_back("Push");
            if (target[index] == i) {
                index++;
            } else {
                ret.push_back("Pop");
            }
            if (i == end_num) break;
        }
        return ret;
    }
};

2. 1021. 删除最外层的括号

    思路：
        利用栈将括号成对匹配，处理边界。非边界括号加入答案。

class Solution {
public:
    string removeOuterParentheses(string s) {
        stack<char> S;
        string ret = "";
        int len = s.length();
        for (int i = 0; i < len; i++) {
            if (S.empty() && s[i] == '(') {
                S.push(s[i]);
            } else if (!S.empty() && S.top() == '(' && s[i] == '(') {
                ret += s[i];
                S.push(s[i]);
            } else if (!S.empty() && S.top() == '(' && s[i] == ')') {
                S.pop();
                if (!S.empty()) ret += s[i];
            }
        }
        return ret;
    }
};

3. 1700. 无法吃午餐的学生数量

    思路：
        按照题意模拟即可，如果学生匹配了超过一轮则结束匹配。

class Solution {
public:
    int countStudents(vector<int>& students, vector<int>& sandwiches) {
        int n = students.size();
        int index_stu = 0, index_sw = 0;
        int limit = 0;
        while (index_sw < n && index_stu < students.size()) {
            if (students[index_stu] == sandwiches[index_sw]) {
                index_stu++;
                index_sw++;
                limit = 0;
            } else {
                students.push_back(students[index_stu]);
                index_stu++;
                if (++limit > n) break; //  如果学生已经循环一轮了，结束匹配
            }
        }
        return students.size() - index_stu;
    }
};

4. 1381. 设计一个支持增量操作的栈

    思路：
        操作很朴素，但是++，--，的过程实现的很艰难，按照自己的想法让top当栈顶一直溢出，最后还是采用让top作为栈顶的上面一个位置。

class CustomStack {
    int top, size;
    int *stk = NULL;
public:
    CustomStack(int maxSize) {
        stk = new int[maxSize + 1];
        size = maxSize;
        top = 0;
    }
    
    void push(int x) {
        if (top < size)
            stk[top++] = x;
    }
    
    int pop() {
        if (top == 0) return -1; 
        else return stk[--top];
    }
    
    void increment(int k, int val) {
        for (int i = 0; i < k; i++) {
            if (i > top) break;
            stk[i] += val;
        }
    }
};

/**
 * Your CustomStack object will be instantiated and called as such:
 * CustomStack* obj = new CustomStack(maxSize);
 * obj->push(x);
 * int param_2 = obj->pop();
 * obj->increment(k,val);
 */