Brackets sequence-uva1626 紫书P278 较复杂动规

首先要明确为什么是用动态规划解这道题？

这个问题是否可以分成更小的子问题？答案是显然的。
只要两个字串互不干扰即可，比如样例的 ([(] 就可以分为 ( 和 [(] 两个子问题，而 [(] 又等价于 ( ，因此找出子问题的最优解就可向上递推最佳结果。符合了动规的两大基本特点：分裂成子问题，寻找子问题的最优解。因此本题是可以用动规来解的。此外动规的复杂度一般在O(n^3)，因此对于数据规模也有一定的要求，本题最多输入100个符号，可以保证不会超时。

解决了能不能用动规的问题后就是怎么写状态转移方程？

dp[i][j]表示i~j的子串需要添加的最少符号数，状态转移方程很容易就能写出来：

dp[i][j]=min(dp[i][k]+dp[k][j],dp[i][j] | i<=k<=j )

在进行递推之前需要对dp数据进行预处理：

for (int i = 0; i < 105; i++)
{
    dp[i][i] = 1; //单个符号时添加一个符号
    dp[i+1][i] = 0; //空字符不需要添加符号
}

但是本题的状态转移方程存在特殊情况，如果遇到()或是[]的时候，如果用上面的方程，得到的结果是2，这是错误的。因此在进行状态转移之前需要添加一步：

if (judge(j, j + i)) //如果s符合(s')或[s']的情况，即两端的符号可以组成一对，那么s的dp可以转移到s'的dp
{
    dp[j][j + i] = dp[j + 1][j + i - 1];
}

不管是否符合这种情况，还是要进行状态转移遍历，因为还有一种特殊情况是[][]，如果跳过了状态转移遍历，就会转移到 ][ ,这显然是不对的。

本题的输出是要打印符号而不是添加的个数，因此也是一个难点。

打印输出可以采用分治的方式，代码的思路比较清楚，在此不做过多解释

void print(int l, int r)
{
    if (l > r)
        return;
    if (l == r)
    {
        if (s[l] == '(' || s[l] == ')')
            printf("()");
        else
            printf("[]");
        return;
    }
    if (judge(l, r) && dp[l][r] == dp[l + 1][r - 1]) //dp[l][r]==dp[l+1][r-1]这个条件不能少，参考[][]的情况
    {
        printf("%c", s[l]);
        print(l + 1, r - 1);
        printf("%c", s[r]);
        return;
    }

    for (int i = l; i <= r; i++) //寻找两个互不干扰的符号段
    {
        if (dp[l][i] + dp[i + 1][r] == dp[l][r]) //互不干扰的成立条件
        {
            print(l, i);
            print(i + 1, r);
            return;
        }
    }
}

最终的AC代码：（本题的输入对格式要求比较高，需要注意换行符号的问题）

#include <bits/stdc++.h>
#define mem(a) memset(a, 0, sizeof(a))
#define inf 0x3f3f3f3f
using namespace std;

char s[105];
int dp[105][105]; //dp[i][j]表示符号i~j所需的最少增加数

inline void init_dp() //预处理dp
{
    mem(dp);
    for (int i = 0; i < 105; i++)
    {
        dp[i][i] = 1;
        dp[i + 1][i] = 0;
    }
}

inline int judge(int l, int r) //判断左右端点是否可以构成一对括号
{
    if (s[l] == '(' && s[r] == ')')
        return 1;
    if (s[l] == '[' && s[r] == ']')
        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("[]");
        return;
    }
    if (judge(l, r) && dp[l][r] == dp[l + 1][r - 1]) //dp[l][r]==dp[l+1][r-1]这个条件不能少，参考[][]的情况
    {
        printf("%c", s[l]);
        print(l + 1, r - 1);
        printf("%c", s[r]);
        return;
    }

    for (int i = l; i <= r; i++) //寻找两个互不干扰的符号段
    {
        if (dp[l][i] + dp[i + 1][r] == dp[l][r]) //互不干扰的成立条件
        {
            print(l, i);
            print(i + 1, r);
            return;
        }
    }
}

int main()
{
    int t, flag = 0;
    cin >> t;
    getchar();
    while (t--)
    {
        init_dp();
        gets(s);
        gets(s);
        int len = strlen(s);
        if (!len) //输入有可能是空字符
        {
            if (flag++)
                putchar(10);
            putchar(10);
            continue;
        }
        for (int i = 1; i < len; i++)
        {
            for (int j = 0; j < len - i; j++)
            {
                dp[j][j + i] = inf;
                if (judge(j, j + i)) //s符合(s')或[s']的情况，那么s的dp和s'的dp相同
                {
                    dp[j][j + i] = dp[j + 1][j + i - 1];
                }
                //不管是否满足第一种转移都要尝试第二种，否则[][]就会转移到][
                for (int k = j; k < j + i; k++)
                {
                    dp[j][j + i] = min(dp[j][j + i], dp[j][k] + dp[k + 1][j + i]);
                }
            }
        }
        if (flag++)
            putchar(10);
        //打印符号
        print(0, len - 1);
        putchar(10);
    }
    return 0;
}