七月集训（14）栈

1.LeetCode: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 次

        用数组模拟栈即可，没什么好说的

int stk[1010];
int capacity;
int top;
class CustomStack {
public:
    CustomStack(int maxSize) {
        capacity=maxSize;
        top=-1;
    }
    
    void push(int x) {
        if(top<capacity-1){
            stk[++top]=x;
        }
    }
    
    int pop() {
        if(top!=-1)
            return stk[top--];
        else return -1;
    }
    
    void increment(int k, int val) {
        int cur=0;
        while(cur<k&&cur<=top){
            stk[cur++]+=val;
        }
        cout<<endl;
    }
};

2.LeetCode:1441. 用栈操作构建数组

原题链接

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

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

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

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

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

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

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

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

        示例 1：

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

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

        示例 2：

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

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

        示例 3：

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

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

        提示：

        1 <= target.length <= 100

        1 <= target[i] <= 100

        1 <= n <= 100

        target 是严格递增的

        由于target是递增的，而题目又告诉我们target是1-n的排列，那么我们就直接统计target中的数字是否出现，然后遍历1-n首先加入push，如果该数字没有出现加入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;
    }
};

3.LeetCode:1614. 括号的最大嵌套深度

原题链接

        如果字符串满足以下条件之一，则可以称之为 有效括号字符串（valid parentheses string，可以简写为 VPS）：

        字符串是一个空字符串 “”，或者是一个不为 “(” 或 “)” 的单字符。

        字符串可以写为 AB（A 与 B 字符串连接），其中 A 和 B 都是 有效括号字符串 。

        字符串可以写为 (A)，其中 A 是一个 有效括号字符串 。

        类似地，可以定义任何有效括号字符串 S 的 嵌套深度 depth(S)：

        depth(“”) = 0

        depth© = 0，其中 C 是单个字符的字符串，且该字符不是 “(” 或者 “)”

        depth(A + B) =
        max(depth(A), depth(B))，其中 A 和 B 都是 有效括号字符串

        depth(“(” + A + “)”) = 1 +
        depth(A)，其中 A 是一个 有效括号字符串

        例如：“”、“()()”、“()(()())” 都是 有效括号字符串（嵌套深度分别为 0、1、2），而 “)(” 、“(()” 都不是 有效括号字符串 。

        给你一个 有效括号字符串 s，返回该字符串的 s 嵌套深度 。

        示例 1：

        输入：s = "(1+(23)+((8)/4))+1"

        输出：3

        示例 2：

        输入：s = “(1)+((2))+(((3)))”

        输出：3

        提示：

        1 <= s.length <= 100

        s 由数字 0-9 和字符 ‘+’、‘-’、'‘、’/‘、’(‘、’)’ 组成

        题目数据保证括号表达式 s 是 有效的括号表达式

        括号匹配类的问题，一贯是左括号入栈，碰到右括号进行处理，本题也不例外，左括号入栈右括号与栈顶左括号匹配出栈，在这之间维护最大的栈内元素个数即可，同时如果栈内元素小于0的话需要直接返回0.。

class Solution {
public:
    int maxDepth(string s) {
        int ans=0;
        int top=0;
        for(int i=0;s[i];++i){
            if(s[i]=='(') ++top;
            else  if(s[i]==')')--top;
            ans=max(ans,top);
            if(top<0){
                return 0;
            }
        }
        return ans;
    }
};

4.LeetCode:剑指 Offer 06. 从尾到头打印链表

原题链接

        输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）

        示例 1：

        输入：head = [1,3,2]

        输出：[2,3,1]

        限制：

        0 <= 链表长度 <= 10000

        本题单纯考查栈的先进后出的性质，也即是后序遍历，所以这里对链表进行后序遍历即可

class Solution {
public:
    vector<int> ans;
    void post_order(ListNode* head){
        if(head==nullptr)return ;
        post_order(head->next);
        ans.push_back(head->val);
    }
    vector<int> reversePrint(ListNode* head) {
        ans.clear();
        post_order(head);
        return ans;
    }
};