NYOJ 15-括号匹配（二）

15-括号匹配（二）

内存限制:64MB 时间限制:1000ms 特判: No
通过数:91 提交数:276 难度:6

题目描述:

给你一个字符串，里面只包含"(",")","[","]"四种符号，请问你需要至少添加多少个括号才能使这些括号匹配起来。
如：
[]是匹配的
([])[]是匹配的
((]是不匹配的
([)]是不匹配的

输入描述:

第一行输入一个正整数N，表示测试数据组数(N<=10)
每组测试数据都只有一行，是一个字符串S，S中只包含以上所说的四种字符，S的长度不超过100

输出描述:

对于每组测试数据都输出一个正整数，表示最少需要添加的括号的数量。每组测试输出占一行

样例输入:

复制

4
[]
([])[]
((]
([)]

样例输出:

0
0
3
2

参考LeetCode32 longest valid parentheses解法。

利用LeetCode32 longest valid parentheses的方法将字符串去掉所有最完美匹配的子串，假设处理后的子串为stringBuffer。在此串的基础上做会简单很多。
对于没有最完美子串的字符串 s 来说，使用d[i][j]表示子串[i,j)需要最少添加的括号数量。需要注意的是像这样的字符串需要另判断，如(])

状态转移方程为：

 

 

import java.util.Scanner;

public class Main{
    static class Solution {
        boolean match(char a, char b) {
            if (a == '(' && b == ')' || a == '[' && b == ']')
                return true;
            return false;
        }

        public int solve(String s) {
            if (s.length()<=1) return s.length();
            int[][] d = new int[s.length()+1][s.length()+1];

            for (int i = 0; i < s.length(); i++) {
                d[i][i] = 0;
                d[i][i + 1] = 1;
            }

            for (int step = 2; step <= s.length(); step++) {
                for (int i = 0; i < s.length() && i+step<s.length()+1; i++) {
                    if (match(s.charAt(i), s.charAt(i + step - 1))) {
                        d[i][i+step]=d[i+1][i+step-1];
                    }else {
                        int min = 65535;
                        for (int k = i + 1; k < i + step; k++) {
                            min = Math.min(d[i][k] + d[k][i + step], min);
                        }
                        d[i][i + step] = min;
                    }
                }
            }
            return d[0][s.length()];
        }
    }

    public static StringBuffer deSubPerfect(String s) {
        int[] d = new int[s.length()];
        int max = 0;

        for (int i = 1; i < s.length(); i++) {
            //查找以i位置结尾的最完美匹配
            int len = 0;
            if (i-1-d[i-1]>=0 && (s.charAt(i) == ')' && '(' == s.charAt(i - 1 - d[i - 1]) || s.charAt(i)==']' && '['==s.charAt(i-1-d[i-1]))){// (())
                len=d[i-1]+2;
            }else if (!(s.charAt(i)==')' && s.charAt(i-1)=='(') || !(s.charAt(i)==']' && '['==s.charAt(i-1-d[i-1]))){// ())
                len=0;
            }else {// (() || ()
                len = 2;
            }

            if (i-len>=0 && len!=0){
                d[i]=d[i-len]+len;
            }else {
                d[i]=len;
            }
            max = (max < d[i]) ? d[i] : max;
        }
        StringBuffer s1 = new StringBuffer();
        for (int i = s.length()-1; i >= 0; i--) {
            i-=d[i];
            if (i>=0)
                s1.append(s.charAt(i));
        }
        StringBuffer reverse = s1.reverse();
        return reverse;
    }

    public static void main(String[] args) {
        String s = new String();
        Scanner sc = new Scanner(System.in);
        Solution solution = new Solution();
        int n = Integer.parseInt(sc.nextLine());
        for (int i = 0; i < n; i++) {
            s=sc.nextLine();
            StringBuffer stringBuffer = deSubPerfect(s);

            int solve = solution.solve(stringBuffer.toString());
            System.out.println(solve);
        }
    }
}
//()(]()
//(())(())