使括号串有效的最少修改次数

字符串中只包含’(‘、’)‘、’[‘、’]‘、’{‘、’}'这6种字符，将此括号串修改为有效的括号串需要的最少修改次数。
题目保证$s$中的个数为偶数。

示例：{[)[，输出为2；{[()，输出为1

思路： 采用动态规划的思想
定义$dp[i][j]$为将$i$到$j$之间的字符修改为有效括号串的最少修改次数。
那么可得，
（1）将中间某一字符修改为和$j$匹配的情况需要的次数，然后就可以将整个问题分解为两个更小的问题。
$dp[i][j]=\min (dp[i][j],{\sum }_{k=i}^{j-1}(dp[i][k-1]+dp[k+1][j-1]+count(s[k],s[j])))$

（2）将中间某一字符修改为和$i$匹配的情况。
$dp[i][j]=\min (dp[i][j],{\sum }_{k=i+1}^j(dp[i][k-1]+dp[k+1][j-1]+count(s[i],s[k])))$

    int get_cur_size(char lh, char rh) {
        if( (lh == '(' && rh == ')') || (lh == '[' && rh == ']') || (lh == '{' && rh == '}')  )
            return 0;
        if( (lh == ')' || lh == ']' || lh == '}') && (rh == '(' || rh == '[' || rh == '{')  )
            return 2;
        return 1;
    }
    int minadd(string s) {  // 将括号串改为有效的最少修改次数
        int n = s.size();
        vector<vector<int>> dp(n, vector<int>(n, 1000));
        // for(int i = 0; i < n; i++) {
        //     for(int j = i; j < n; j++) {
        //         if( (j - i + 1) % 2 != 0 ) {
        //             dp[i][j] = 1000;
        //         }
        //     }
        // }
        for(int len = 2; len <= n; len += 2) { 
            for(int i = 0; i < n - len + 1; i++) {
                int j = i + len - 1;
                for(int k = i; k < j; k++) {
                    int tmp = get_cur_size(s[k], s[j]);
                    if(k - 1 >= i) {
                        tmp += dp[i][k-1];
                    }
                    if( k+1 <= j - 1 ) {
                        tmp += dp[k+1][j-1];
                    }
                    dp[i][j] = min(dp[i][j], tmp);
                }
                for(int k = i + 1; k <= j; k++) {
                    int tmp = get_cur_size(s[i], s[k]);
                    if(k - 1 >= i + 1) {
                        tmp += dp[i + 1][k-1];
                    }
                    if( k+1 <= j ) {
                        tmp += dp[k+1][j];
                    }
                    dp[i][j] = min(dp[i][j], tmp);
                }
            }
        }
        return dp[0][n-1];
    }