POJ 1141 Brackets Sequence (DP)

最初看这个问题，有些困惑，不是对每个没配对上的括号补齐括号就可以了吗。不过没这么简单，如果只有一种括号，不同的补齐方法，都只需要补齐相同数目的括号。而这里有两种括号，在交错的情况下，不同的补齐方法，需要补齐的扩号数可能不一样。看下面的例子:

[[(]])

补齐方法:

[[()]]()

[[]]([][])

......

这个问题要求我们找出，需要补齐的括号数最少的方法之一（Special Judge）。

搞清题意之后，再来看这个问题。可以用DP来解答。

令 dp[i][j] 表示输入串在[i,j]这一段需要补齐的最少括号数，有

(1) 若in[i]和in[j]匹配括号，取dp[i][j] = dp[i+1][j-1] 记 k=-1

(2) 其他可能的情况：dp[i][j] = dp[i][k] + dp[k+1][j] (i=<k<j)

那么 dp[i][j] = Min{(1), (2)}，另外用path[i][j]记住每一步选择的k值，以输出最优解。

#include <iostream>
#include <string.h>

using namespace std;

char in[101];
int dp[101][101];    // least brackets to be added between in[i, j]
int path[101][101];  // break point of dp[i][j]

void getMinRegularSeq(int len)
{
memset(dp, -1, sizeof(dp));
memset(path, -1, sizeof(path));

// dp bottom-up
for (int i = len-1; i >= 0; --i)
{
for (int j = i; j < len; ++j)
{
if (i == j)
{
dp[i][j] = 1;
path[i][j] = i;
continue;
}

if ( (in[i] == '(' && in[j] == ')')
|| (in[i] == '[' && in[j] == ']'))
{
path[i][j] = -1;
if (j-i > 1)
{
dp[i][j] = dp[i+1][j-1];
}
else
{
dp[i][j] = 0;
continue;     // least already
}
}

for (int k = i; k < j; ++k)
{
if (dp[i][j] == -1 || dp[i][k]+dp[k+1][j] < dp[i][j])
{
dp[i][j] = dp[i][k]+dp[k+1][j];
path[i][j] = k;
}
}
}
}
}

void printMinRegularSeq(int l, int r)
{
if (l > r) return;
if (l == r)
{
if (in[l] == '(' || in[l] == ')') cout << "()";
if (in[l] == '[' || in[l] == ']') cout << "[]";
}
else
{
if (path[l][r] == -1)
{
cout << in[l];
printMinRegularSeq(l+1,r-1);
cout << in[r];
}
else
{
printMinRegularSeq(l, path[l][r]);
printMinRegularSeq(path[l][r]+1, r);
}
}
}

int main(int argc, char** argv)
{
cin.getline(in, 101);
int len = strlen(in);
if (len > 0)
{
getMinRegularSeq(len);
printMinRegularSeq(0, len-1);
}
cout << endl;
return 0;
}