算法专练：栈

1.1441. 用栈操作构建数组

原题链接

        给你一个目标数组 target 和一个整数 n。每次迭代，需要从 list = {1,2,3…, n} 中依序读取一个数字。

        请使用下述操作来构建目标数组 target ：

        Push：从 list 中读取一个新元素， 并将其推入数组中。

        Pop：删除数组中的最后一个元素。

        如果目标数组构建完成，就停止读取更多元素。

        题目数据保证目标数组严格递增，并且只包含 1 到 n 之间的数字。

        请返回构建目标数组所用的操作序列。

        题目数据保证答案是唯一的。

        示例 1：

        输入：target = [1,3], n = 3

        输出：[“Push”,“Push”,“Pop”,“Push”]

        解释：

        读取 1 并自动推入数组 -> [1]

        读取 2 并自动推入数组，然后删除它 -> [1]

        读取 3 并自动推入数组 -> [1,3]

        示例 2：

        输入：target = [1,2,3], n = 3

        输出：[“Push”,“Push”,“Push”]

        示例 3：

        输入：target = [1,2], n = 4

        输出：[“Push”,“Push”]

        解释：只需要读取前 2 个数字就可以停止。

        提示：

        1 <= target.length <= 100

        1 <= target[i] <= 100

        1 <= n <= 100

        target 是严格递增的

        首先我们注意到了提示中告诉了我们target数组是严格递增的，这就使得本题的做法十分简单了。首先我们创建一个哈希表，并且把target的元素全部映射到哈希表中，并在该过程中维护一个最大值max.

        之后就是对ans的处理，首先对于从1到max的每一个数字不管他是不是target中的数我们都要先把他加入进来ans加入一个“push",如果target中不含有当前检查的数字我们加入一个"pop"即可。

class Solution {
public:
    vector<string> buildArray(vector<int>& target, int n) {
        int index=0;
        int t=1;
        vector<string> ans;
        int hash[105];
        memset(hash,0,sizeof(hash));
        int max=INT_MIN;
        for(int i=0;i<target.size();++i){
            hash[target[i]]++;
            max=target[i]>max?target[i]:max;
        }
        for(int i=1;i<=max;++i){
            ans.push_back("Push");
            if(!hash[i]){
                ans.push_back("Pop");
            }
        }
        return ans;
    }
};

2.1021. 删除最外层的括号

原题链接

        有效括号字符串为空 “”、“(” + A + “)” 或 A + B ，其中 A 和 B 都是有效的括号字符串，+ 代表字符串的连接。

        例如，“”，“()”，“(())()” 和 “(()(()))” 都是有效的括号字符串。

        如果有效字符串 s 非空，且不存在将其拆分为 s = A + B 的方法，我们称其为原语（primitive），其中 A 和 B 都是非空有效括号字符串。

        给出一个非空有效字符串 s，考虑将其进行原语化分解，使得：s = P_1 + P_2 + … + P_k，其中 P_i 是有效括号字符串原语。

        对 s 进行原语化分解，删除分解中每个原语字符串的最外层括号，返回 s 。

        示例 1：

        输入：s = “(()())(())”

        输出：“()()()”

        示例 2：

        输入：s = “(()())(())(()(()))”

        输出：“()()()()(())”

        示例 3：

        输入：s = “()()”

        输出：“”

        提示：

        1 <= s.length <= 10^5

        s[i] 为 ‘(’ 或 ‘)’

        s 是一个有效括号字符串

        看到10^5数据的括号匹配但是官方把他定义为了简单题就说明了这道题是真的简单。

        我们观察每个字符串，我们要做的就是去掉字符串中所有最外层括号把他变为A+B,(A+B),(A)的形式。那么我们就利用一个栈吧所有的左括号都加入到栈中，但是这时候我们要明白一点，如果是在栈为空的时候加入的左括号，那么他就是最外层的左括号，我们不进行操作，如果是在栈非空的时候加入的左括号我们在答案字符串中同样也要加入一个左括号。

        此外每遇到一个右括号我们就去删除栈中的一个左括号代表该对括号进行了匹配，并且在删除后栈非空的情况下在答案中加入一个右括号，如果删除后栈为空就说明该对匹配括号是最外层的括号，同样不进行操作。

class Solution {
    stack<char> stk;
public:
    string removeOuterParentheses(string s) {
        string ans;
        for(int i=0;i<s.size();++i){
            if(s[i]=='('&&stk.empty()){
                stk.push('(');
            }else if(s[i]=='('&&!stk.empty()){
                stk.push('(');
                ans+='(';
            }else if(s[i]==')'){
                stk.pop();
                if(!stk.empty()){
                    ans+=')';
                }
            }
        }
        return ans;
    }
};

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

原题链接

        请你设计一个支持下述操作的栈。

        实现自定义栈类 CustomStack ：

        CustomStack(int maxSize)：用 maxSize 初始化对象，maxSize 是栈中最多能容纳的元素数量，栈在增长到 maxSize 之后则不支持 push 操作。

        void push(int x)：如果栈还未增长到 maxSize ，就将 x 添加到栈顶。

        int pop()：弹出栈顶元素，并返回栈顶的值，或栈为空时返回 -1 。

        void inc(int k, int val)：栈底的 k 个元素的值都增加 val 。如果栈中元素总数小于 k ，则栈中的所有元素都增加 val 。

        示例：

        输入：

        [“CustomStack”,“push”,“push”,“pop”,“push”,“push”,“push”,“increment”,“increment”,“pop”,“pop”,“pop”,“pop”]

        [[3],[1],[2],[],[2],[3],[4],[5,100],[2,100],[],[],[],[]]

        输出：

        [null,null,null,2,null,null,null,null,null,103,202,201,-1]

        提示：

        1 <= maxSize <= 1000

        1 <= x <= 1000

        1 <= k <= 1000

        0 <= val <= 100

        每种方法 increment，push 以及 pop 分别最多调用 1000 次

没什么好说的按照题目进行模拟即可不过这里直接利用了数组模拟栈，又利用了该数组来进行操作。

class CustomStack {
    int top,size;
    int *my_stk;
public:
    CustomStack(int maxSize) {
        my_stk=new int[maxSize+1];
        size=maxSize;
        top=0;
    }
    
    void push(int x) {
        if(top<size)
        my_stk[top++]=x;
    }
    
    int pop() {
        if(top==0){
            return -1;
        }
        return my_stk[--top];//top是比数组中的最后一个下标大一的这里要注意
    }
    
    void increment(int k, int val) {
        for(int i=0;i<k&&i<top;++i){
            my_stk[i]+=val;
        }
    }
};

4.1700. 无法吃午餐的学生数量

原题链接

        学校的自助午餐提供圆形和方形的三明治，分别用数字 0 和 1 表示。所有学生站在一个队列里，每个学生要么喜欢圆形的要么喜欢方形的。

        餐厅里三明治的数量与学生的数量相同。所有三明治都放在一个 栈 里，每一轮：

        如果队列最前面的学生 喜欢 栈顶的三明治，那么会 拿走它 并离开队列。

        否则，这名学生会 放弃这个三明治 并回到队列的尾部。

        这个过程会一直持续到队列里所有学生都不喜欢栈顶的三明治为止。

        给你两个整数数组 students 和 sandwiches ，其中 sandwiches[i] 是栈里面第 i​​​​​​ 个三明治的类型（i = 0 是栈的顶部）， students[j] 是初始队列里第 j​​​​​​ 名学生对三明治的喜好（j = 0 是队列的最开始位置）。请你返回无法吃午餐的学生数量。

        示例 1：

        输入：students = [1,1,0,0], sandwiches = [0,1,0,1]

        输出：0

        示例 2：

        输入：students = [1,1,1,0,0,1], sandwiches = [1,0,0,0,1,1]

        输出：3

        提示：

        1 <= students.length,
        sandwiches.length <= 100

        students.length == sandwiches.length

        sandwiches[i] 要么是 0 ，要么是 1 。

        students[i] 要么是 0 ，要么是 1 。

        不断用学生与三明治数组进行匹配，如果匹配失败就在学生数组中尾插当前学生。但是注意这里在无论如何都无法匹配的时候会死循环所以我们要设立一个limit来进行限制。

class Solution {
public:
    int countStudents(vector<int>& students, vector<int>& sandwiches) {
        int aindex=0,sindex=0;
        int limit;
        while(sindex<students.size( ) && aindex < sandwiches.size()){
            if(students[sindex]==sandwiches[aindex]){
                ++sindex,++aindex;
            }else {
                students.push_back(students[sindex]);
                sindex++;
                if(limit++>201){
                    break;
                }
            }
        }
        return students.size()-sindex;
    }
};