C++和Java的stack语法

栈一种容器，遵循先进后出原则，，只能在栈的顶部操作，就像放盘子一样，洗好的盘子叠在上面，需要用时也是先从顶部拿。不允许被遍历。

一、C++stl中的stack语法

• 1.头文件#include<stack>
• 2.top()  返回栈顶元素
• 3.pop()  弹出栈顶元素
• 4.empty()若栈空返回true，非空返回false
• 5.size() 返回栈的元素个数，在c++判断里，0是false，非0是true，作用可以上可以替代empty()
• 6.push() 入栈

二、java里的Stack类

1. mport java.util.Stack;//导入包
2. Stack<E> stack=new Stack<E>();//初始化，E表示类，不能是基本类型int之类的
3. push(x);//入栈
4. pop();//出栈
5. peek();//取头元素
6. empty();//判空，空为true
7. search(x);//寻找元素x距离栈顶的位置，在栈顶返回1，倒数第二入栈的返回2，如果不在栈中返回-1；

例题：CF990C-Bracket Sequences Concatenation Problem

题解：给出好多好多个括号序列，求某两个序列拼起来能构造出完整的括号匹配序列的 序列对数，可以重复使用。

括号序列分4种情况

1.类似“（（（（））”和“（）（（（”这类消去自身已经匹配的括号后剩下的全是左括号

2.类似“（（））））”和“（））））”这类消去自身已经匹配的括号后剩下的全是右括号

3.类似“（）（）（）（）”和“（（））（）”这类自身能作为完整括号匹配的

4.类似“（））（”和“）））（（（））（）”这类消去自身已经匹配的括号后剩下的不是以上任意一种的。无论和其他哪个序列拼接都没办法构造出完整的括号匹配序列。

最终答案=相同剩余单边括号数量的第1、2种情况序列数量之和 + 第3种²

import java.util.Scanner;
import java.util.Stack;

public class Main{

    public static void main(String []args){
        long [] l = new long[300005];
        long [] r = new long[300005];
        long ok=0;//圆满的序列
        long ans=0;
        Scanner scan=new Scanner(System.in);
        int n;
        while(scan.hasNext()) {
            ans=0;
            ok=0;
            n=scan.nextInt();
            for(int i=1;i<=n;i++){
                Stack<Character> stack=new Stack<Character>();
                String s=scan.next();
                int len=s.length();
                for(int j=0;j<len;j++){
                    Character x=s.charAt(j);
                    if(x=='(')//左括号直接入栈
                        stack.push(x);
                    if(x==')') {//右括号判断栈顶，如果是（则弹出
                        if(!stack.empty()&&stack.peek()=='(')
                            stack.pop();
                        else//空或者里面也是)
                            stack.push(x);
                    }
                }
                boolean flag=true;//判断这个字符串可不可以作为题目要求的序列
                int left=0,right=0;
                while(!stack.empty()) {
                    Character now=stack.peek();
                    stack.pop();
                    if(now=='(')
                        left++;
                    else 
                        right++;
                    if(left!=0 && right!=0) {
                        flag=false;
                        break;
                    }
                }
                if(flag==true) {
                    if(left==0 && right==0)
                        ok++;
                    else if(left!=0)
                        l[left]++;
                    else 
                        r[right]++;
                }
            }
            for(int i=1;i<300005;i++) {
                ans=ans+(l[i]*r[i]);
                l[i]=r[i]=0;
            }
            ans=ans+ok*ok;
            System.out.println(ans);
        }

    }
}