Ural 1183 Brackets Sequence(区间DP+记忆化搜索)

题目地址：Ural 1183

最终把这题给A了。。

。拖拉了好长时间，。。

自己想还是想不出来，正好紫书上有这题。

d[i][j]为输入序列从下标i到下标j最少须要加多少括号才干成为合法序列。0<=i<=j<len (len为输入序列的长度)。

c[i][j]为输入序列从下标i到下标j的断开位置。假设没有断开则为-1。



当i==j时。d[i][j]为1



当s[i]=='(' && s[j]==')' 或者 s[i]=='[' && s[j]==']'时，d[i][j]=d[i+1][j-1]



否则d[i][j]=min{d[i][k]+d[k+1][j]} i<=k<j ，  c[i][j]记录断开的位置k



採用递推方式计算d[i][j]



输出结果时採用递归方式输出print(0, len-1)





输出函数定义为print(int i, int j)，表示输出从下标i到下标j的合法序列





当i>j时。直接返回，不须要输出





当i==j时。d[i][j]为1，至少要加一个括号。假设s[i]为'(' 或者')'。输出"()"，否则输出"[]"





当i>j时，假设c[i][j]>=0。说明从i到j断开了。则递归调用print(i, c[i][j]);和print(c[i][j]+1, j);





                假设c[i][j]<0，说明没有断开。假设s[i]=='(' 则输出'('、 print(i+1, j-1); 和")"





                                                                     否则输出"[" print(i+1, j-1);和"]"

代码例如以下：

#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include <queue>
#include <map>
#include <set>
#include <algorithm>

using namespace std;
#define LL __int64
const int INF=0x3f3f3f3f;
char s[200];
int dp[110][110], tag[110][110];
int match(char c1, char c2)
{
    if((c1=='('&&c2==')')||(c1=='['&&c2==']'))
        return 1;
    return 0;
}
void print(int l, int r)
{
    if(l>r) return ;
    if(l==r)
    {
        if(s[l]=='('||s[l]==')')
            printf("()");
        else
            printf("[]");
    }
    else if(tag[l][r]==-1)
    {
        printf("%c",s[l]);
        print(l+1,r-1);
        printf("%c",s[r]);
    }
    else
    {
        print(l,tag[l][r]);
        print(tag[l][r]+1,r);
    }
}
int main()
{
    int n, m, i, j, len, k;
    gets(s);
    len=strlen(s);
    if(len==0)
    {
        puts("");
    }
    memset(dp,INF,sizeof(dp));
    memset(tag,-1,sizeof(tag));
    for(i=0;i<len;i++)
    {
        dp[i][i]=1;
        dp[i+1][i]=0;
    }
    for(i=len-2;i>=0;i--)
    {
        for(j=i+1;j<len;j++)
        {
            dp[i][j]=len+1;
            if(match(s[i],s[j]))
            {
                dp[i][j]=min(dp[i][j],dp[i+1][j-1]);
            }
            for(k=i;k<=j;k++)
            {
                if(dp[i][j]>dp[i][k]+dp[k+1][j])
                {
                    dp[i][j]=dp[i][k]+dp[k+1][j];
                    tag[i][j]=k;
                }
            }
        }
    }
    //printf("%d\n",dp[0][len-1]);
    /*for(i=0;i<4;i++)
    {
        for(j=0;j<4;j++)
        {
            printf("%d ",tag[i][j]);
        }
        puts("");
    }*/
    print(0,len-1);
    puts("");
    return 0;
}