(2018网易编程)最长公共子括号序列

一个合法的括号匹配序列被定义为:
1. 空串""是合法的括号序列
2. 如果"X"和"Y"是合法的序列,那么"XY"也是一个合法的括号序列
3. 如果"X"是一个合法的序列,那么"(X)"也是一个合法的括号序列
4. 每个合法的括号序列都可以由上面的规则生成
例如"", "()", "()()()", "(()())", "(((()))"都是合法的。
从一个字符串S中移除零个或者多个字符得到的序列称为S的子序列。
例如"abcde"的子序列有"abe","","abcde"等。
定义LCS(S,T)为字符串S和字符串T最长公共子序列的长度,即一个最长的序列W既是S的子序列也是T的子序列的长度。
小易给出一个合法的括号匹配序列s,小易希望你能找出具有以下特征的括号序列t:
1、t跟s不同,但是长度相同
2、t也是一个合法的括号匹配序列
3、LCS(s, t)是满足上述两个条件的t中最大的
因为这样的t可能存在多个,小易需要你计算出满足条件的t有多少个。

如样例所示: s = "(())()",跟字符串s长度相同的合法括号匹配序列有:
"()(())", "((()))", "()()()", "(()())",其中LCS( "(())()", "()(())" )为4,其他三个都为5,所以输出3. 

输入描述:

输入包括字符串s(4 ≤ |s| ≤ 50,|s|表示字符串长度),保证s是一个合法的括号匹配序列。

输出描述:

输出一个正整数,满足条件的t的个数。

输入例子1:

(())()

输出例子1:

3

思路：从输入之中提取一个字符，和被提取后剩余的字符串进行组合，组合出所有可能的字符串。先去除所有可能字符串中重复的字符串，然后再判断合法字符串个数。字符串合法个数减1（因为组合的字符串必有和输入字符串相同的字符串）即为最大的子字符串的个数。

代码：

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
public class SequenceMatching {
    public static void main(String[] args){
        Scanner scanner = new Scanner(System.in);
        String s = scanner.next();
        StringBuffer sb = new StringBuffer();
        sb.append(s);

        int stringlength = s.length();
        char[] ch = new char[stringlength];

        //初始化StringBuffer
        StringBuffer[] stringBuffer = new StringBuffer[stringlength];
        for(int i=0;i < stringlength;i++){
            stringBuffer[i] = new StringBuffer();
        }
        //提取出一个字符ch[i],提取出剩余字符stringBuffer[i]
        StringBuffer temp1 = new StringBuffer();
        for(int i=0;i < stringlength;i++){
            ch[i] = sb.charAt(i);
            temp1.append(sb);
            stringBuffer[i].append( temp1.deleteCharAt(i) );
            temp1.delete(0,temp1.length());
        }

        //构造stringBuffer
        StringBuffer[][] stringBuffer2 = new StringBuffer[stringlength][stringlength];
        for(int i=0;i < stringlength;i++){
            for(int j=0;j < stringlength;j++){
                 stringBuffer2[i][j] = new StringBuffer();
            }
        }

        //构造字符ch[i]和stringBuffer[][]的所有组合方式的数组
        StringBuffer temp = new StringBuffer();
        for(int i=0;i < stringlength;i++){
            for(int j=0;j < stringlength;j++){
                temp.append( stringBuffer[i] );
                stringBuffer2[i][j].append(temp.insert(j,ch[i]));
                temp.delete(0,temp.length());
            }
        }


        //只插入非重复元素到list
        List<String> list = new ArrayList<String>();
        for(int i=0;i < stringlength;i++) {
            for (int j = 0; j < stringlength; j++) {
                if(!list.contains(stringBuffer2[i][j].toString())){
                    list.add(stringBuffer2[i][j].toString());
                }
            }
        }

        //统计字符串合法个数
        int t=0;
        StringBuffer stringBuffer5 = new StringBuffer();
        for(String string1:list){
            stringBuffer5.append(string1);
            if( isLeagal(stringBuffer5) ){
                t++;
                stringBuffer5.delete(0,stringBuffer5.length());
            }
        }
        //输出需要减一，因为所有组合字符串中必定有一个与输入字符串相同
        System.out.print(t-1);
}
    //判断方式：例子：(()()())  碰到有相邻的()就删除，继续判断剩余的字符串继续删除
    //如果能删除尽就说明这个字符串合法
    private static boolean isLeagal(StringBuffer stringBuffer){
        for(int j=0;j <= 10000;j++){
            for(int m=0;m < stringBuffer.length()-1;m++){
                if( stringBuffer.charAt(m) == '(' && stringBuffer.charAt(m+1) == ')'){
                    stringBuffer.deleteCharAt(m);
                    stringBuffer.deleteCharAt(m);
                }
            }
        }
        if(stringBuffer.length() == 0){
            stringBuffer.delete(0,stringBuffer.length());
            return true;
        }
        stringBuffer.delete(0,stringBuffer.length());
        return false;
    }
}