括号匹配问题（区间dp）

简单的检查括号是否配对正确使用的是栈模拟，这个不必再说，现在将这个问题改变一下：如果给出一个括号序列，问需要把他补全成合法最少需要多少步？

这是一个区间dp问题,我们可以利用区间dp来解决，直接看代码吧！

 /* ***********************************************
 Author        :xiaowuga
 Created Time  :2017年10月03日 星期二 14时20分04秒
 File Name     :Desktop/text.cpp
 ************************************************ */
 #include <bits/stdc++.h>
 #define mem(s,ch) memset(s,ch,sizeof(s))
 typedef long long LL;
 #define inf 0x3f3f3f3f
 const long long N=;
 const long long mod=1e9+;
 #define endl '\n'
 using namespace std;
 bool check(char a,char b){
     if((a=='('&&b==')')||(a=='['&&b==']')) return true;
     else return false;
 }
 int dp[][];
 string q;
 int main(){
     ios::sync_with_stdio(false);cin.tie();
     int n;
     cin>>n;
     while(n--){
         cin>>q;
         int len=q.size();
         memset(dp,,sizeof(dp));
         for(int i=;i<len;i++) dp[i][i]=;
         for(int i=len-;i>=;i--){
             for(int j=i+;j<len;j++){
                 dp[i][j]=inf;
                 if(check(q[i],q[j])) dp[i][j]=dp[i+][j-];
                 for(int k=i;k<j;k++){
                     dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+][j]);
                 }
             }
         }
         cout<<dp[][len-]<<endl;
     }
     return ;
 }

虽然也有记忆化搜索的做法，但是刷表的方法似乎代码量更短，区间dp的刷表有一个特点i和j总是反过来，这是为什么呢？由于区间dp中大区间的答案依赖于小区间，所以我们在更新大区间答案的时候一定要保证向他发生状态转移的小区间都已经得出了答案。所以：

for(int i=len-2;i>=0;i--){

　　for(int j=i;j<len;j++){

　　}

}

自己枚举一下更新区间的顺序就会发现，当我们需要更新区间dp[i][j]的答案的时候dp[i][k-1]和dp[k+1][j]都已经更新了。

现在来解释一下：两种转移方式

　　1.如果q[i]和q[j]是可以匹配的，dp[i][j]=dp[i-1][j-1](显然不解释了）

　　2.对于一个区间，我们考虑把他分解成两个子区间，那么如果得到最优的子区间分配呢？答案是枚举，枚举所有的分配方式即

<[i,i],[i+1][j]>,<[i,i+1],[i+2,j]>,<[i,i+2],[i+3,j]>,<[i,i+3],[i+4,j]>,…………<[i,j-1],[j,j]>，找到所有分配方式最小值。

对于每一个区间我们找以上两种转移方式的最小值。

如果要打印打印方案（代码）：

 void print(int l,int r){
     if(l>r) return;
     if(l==r){
         if(q[l]=='('||q[l]==')') cout<<"()";
         else if(q[l]=='['||q[l]==']') cout<<"[]";
         return ;
     }
     if(check(q[l],q[r])&&dp[l][r]==dp[l+][r-]){
         cout<<q[l];
         print(l+,r-);
         cout<<q[r];
         return ;
     }
     for(int k=l;k<r;k++){
         if(dp[l][r]==dp[l][k]+dp[k+][r]){
             print(l,k);
             print(k+,r);
             return ;
         }
     }
 }

这个这里相当于一个逆过程，如果你看了记忆化搜索代码应该就会很好理解这个代码了

记忆化搜索：

 int dp(int x,int y){
    int &ans=d[x][y];
    if(x>y) return ;
    if(ans>||x==y) return ans;
    ans=n;
    if(match(str[x],str[y])) ans=min(ans,dp(x+,y-));
    for(int i=x;i<y;i++){
             ans=min(ans,dp(x,i)+dp(i+,y));
     }
    return ans;
 }

练习题：

http://acm.nyist.net/JudgeOnline/problem.php?pid=15

https://vjudge.net/problem/UVA-1626