poj 1141

 题目大意，给出一个表达式的子序列，要你填充这个序列，保证最终形成的序列长度最短，也就是添加的括号最少

这个子序列要遵循括号匹配的原则。

这道题目的思想和《算法导论》里动态规划里介绍的求多个矩阵相乘需要的操作最小是一样的

dp[i][j] 表示i到j坐标所要求加括号最小的个数

那么dp[i][j] = min(dp[i][k] + dp[k+1][j])    i < j,    i<=k < j

dp[i][i] = 1;

当s[i] = '(' , s[j] = ')'或者s[i] = '[', s[j] = ']'时，dp[i][j]初始化为dp[i+1][j-1]然后在跟后续比较。在求的过程中用path[i][j]保存划分的坐标位置，最后递归输出

 

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
using namespace std;
const int maxn = 110;

char str[maxn];
int dp[maxn][maxn], path[maxn][maxn], len;

void output(int st, int ed);

int main()
{
    
    memset(dp, 0, sizeof(dp));
    scanf("%s", str + 1);
    len = strlen(str + 1);
    for(int i = 1; i <= len; i++)
        dp[i][i] = 1;
    for(int l = 2; l <= len; l++)
    {
        for(int i = 1; i <= len - l + 1; i++)
        {
            int j = i + l - 1;
            if(str[i] == '(' && str[j] == ')' || str[i] == '[' && str[j] == ']')
            {
                dp[i][j] = dp[i+1][j-1];
                path[i][j] = -1;
            }
            else
                dp[i][j] = 0x7fffffff;
            for(int k = i; k <= j - 1; k++)
            {
                if(dp[i][j] > dp[i][k] + dp[k+1][j])
                {
                    dp[i][j] = dp[i][k] + dp[k+1][j];
                    path[i][j] = k;
                }
            }
        }
    }
    output(1, len);
    printf("\n");
    
    return 0;
}

void output(int st, int ed)
{
    if(st > ed)
        return;
    else if(st == ed)
    {
        if(str[st] == '(' || str[ed] == ')')
            printf("()");
        else
            printf("[]");
    }
    else if(path[st][ed] == -1)
    {
        printf("%c", str[st]);
        output(st+1, ed - 1);
        printf("%c", str[ed]);
    }
    else
    {
        output(st, path[st][ed]);
        output(path[st][ed] + 1, ed);
    }
}