stl-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() 入栈

栈的经典问题：括号配对问题

描述

现在，有一行括号序列，请你检查这行括号是否配对。

输入

第一行输入一个数N（0<N<=100）,表示有N组测试数据。后面的N行输入多组输入数据，每组输入数据都是一个字符串S(S的长度小于10000，且S不是空串），测试数据组数少于5组。数据保证S中只含有"[", "]", "(", ")" 四种字符

输出

每组输入数据的输出占一行，如果该字符串中所含的括号是配对的，则输出Yes,如果不配对则输出No

样例输入

3
[(])
(])
([[]()])

样例输出

No
No
Yes

思路：括号的配对也是遵循栈的工作原理，最里面的括号优先配对。从第一个括号开始遍历，如果是左括号，入栈，如果是右括号并且和栈顶的左括号配对，就出栈一个左括号，通过栈来判断括号是否配对。

AC代码：

#include<stdio.h>
#include<iostream>
#include<algorithm>
#include<cstring>
#include<math.h>
#include<string>
#include<queue>
#define ll long long
#define inf 0x3f3f3f3f
using namespace std;

int t;
string a,b;
int dp[][];

int main()
{
    cin>>t;
    while(t--)
    {
        cin>>a;
        b="";
        int len=a.size();
        for(int i=len-;i>=;i--)
            b=b+a[i];
        //cout<<b<<endl;
        memset(dp,,sizeof(dp));

        for(int i=;i<len;i++)
        {
            for(int j=;j<len;j++)
            {
                if(a[i]==b[j])
                    dp[i+][j+]=dp[i][j]+;///当i=j=0并且字符相等时，dp[1][1]中的1代表两个字符串比较的字符个数
                else
                    dp[i+][j+]=max(dp[i+][j],dp[i][j+]);
            }
        }
       // printf("%d\n",dp[len][len]);
        printf("%d\n",len-dp[len][len]);
    }

}

二、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);
        }

    }
}

CF990C