括号匹配方案

合法的括号匹配序列被定义为:
1. 空串""是合法的括号序列
2. 如果"X"和"Y"是合法的序列,那么"XY"也是一个合法的括号序列
3. 如果"X"是一个合法的序列,那么"(X)"也是一个合法的括号序列
4. 每个合法的括号序列都可以由上面的规则生成
例如"", "()", "()()()", "(()())", "(((())))"都是合法的。 东东现在有一个合法的括号序列s,一次移除操作分为两步:
1. 移除序列s中第一个左括号
2. 移除序列s中任意一个右括号.保证操作之后s还是一个合法的括号序列
东东现在想知道使用上述的移除操作有多少种方案可以把序列s变为空
如果两个方案中有一次移除操作移除的是不同的右括号就认为是不同的方案。
例如: s = "()()()()()",输出1, 因为每次都只能选择被移除的左括号所相邻的右括号.
s = "(((())))",输出24, 第一次有4种情况, 第二次有3种情况, ... ,依次类推, 4 * 3 * 2 * 1 = 24 

输入描述:

输入包括一行,一个合法的括号序列s,序列长度length(2 ≤ length ≤ 20).

 

输出描述:

输出一个整数,表示方案数

 

输入例子1:

(((())))

 

输出例子1:

24

方法一：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Scanner;

//括号匹配方案
public class Ztry9 {
    static char[] ar;
    static int sum=0;
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner sc = new Scanner(System.in);
        String str = sc.nextLine();
        ar = str.toCharArray();
        int length=ar.length;
        List  list=new ArrayList<>();
           for(int i=0;i                list.add(ar[i]);
            }
           //System.out.println(list);
           solve(list);
           System.out.println(sum);
    }
    public static void solve(List  list){
        int size=list.size();
       for(int i=0;i            if(list.get(i)=='('){
               for(int j=i+1;j                    if(list.get(j)==')') {
                       List  alist=new ArrayList<>(); 
                       for(int k=0;k                            alist.add(list.get(k));
                        }  
                       alist.remove(i);
                       alist.remove(j-1);
                       if(isVaild(alist)){
                           alist.clear();
                           
                           for(int k=0;k                            alist.remove(i);
                           alist.remove(j-1);
                           solve(alist); 
                           //System.out.println(alist);   
                       }
                        
                   }
                 
               }
               return ;     
           }
           
        }
       
       if(list.contains('(')||list.contains(')')) return;
      
        
       sum++;
    }
    
    public static boolean isVaild(List  list){
    
        for(int k=0;k             if(list.get(k)==')'){
                for(int i=k-1;i>-1;i--){
                    if(list.get(i)=='('){
                        list.remove(i);    
                        list.remove(k-1);
                        
                      return  isVaild(list);
                       
                    }
                }
                return false;
             }
              
        } 
        
         if(list.contains('(')) return false;
    return true;
    }
    
}
 

方法二：

import java.util.Scanner;

import java.util.Stack;

public class BracketMatch {

    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        String s = sc.next();

 

        Stack stack = new Stack<>();

        int result = 1;

        char c;

 

        for (int i = 0; i < s.length(); i++) {

            c = s.charAt(i);

            if (c == '(') {

                stack.push(c);

 

            }

            if (c == ')') {

                int size = stack.size();

                result *= size;

                stack.pop();

            }

        }

 

        System.out.println(result);

    }

}