Brackets sequence

UVA1626
这是一道区间动态规划。
定义： $dp[i][j]$为从第 $i$个字符到第 $j$个字符组成的子串要成为正规子串最少要添加多少字符， $S$为字符串。
初始化：

1. $dp[i][i]=1$
   一个字符必定需要补充另一个才能匹配。
2. $dp[i+1][i]=0$
   在转移方程中的 $dp[i][j]=dp[i+1][j-1]$里，若 $j=i+1$且 $S[i]$与 $S[j]$匹配，则 $dp[i+1][j-1]=dp[i+1][i]=0$，即此时不需要补充字符。
3. 其余 $dp$元素 $=|S|$
   需要补充的数量再长与不会超过 $|S|$

判断匹配：

bool Match(const char& Left, const char& Right) {
	return
		Left == '(' && Right == ')'
		||
		Left == '[' && Right == ']';
}

转移方程：

for (int i = s.size() - 2; i >= 0; --i) {
		for (int j = i + 1; j < s.size(); ++j) {
			dp[i][j] = s.size();
			//如果i与j匹配
			if (Match(s[i],s[j])) {
				//那i+1到j-1组成的子串在左右各拓展一个字符时不需要再去添加额外的字符，因为新添加的两个字符匹配且对称
				dp[i][j] = min(dp[i][j], dp[i + 1][j - 1]);
			}
			//枚举中转点
			for (int k = i; k < j; ++k) {
				dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j]);
			}
		}
	}

至此，我们得到了每一个子串变成正规子串的最少字符添加数。
答案输出：
可以采用递归形式输出。
定义： $Output(i,j)$函数输出i到j字符组成的子串对应的答案。

void Output(int i, int j) {
	//此时不输出，直接返回
	if (i > j) {
		return;
	}
	//此时括号字符落单，原字符串中没有与之匹配的，直接为它配一个
	else if (i == j) {
		printf((s[i] == '(' || s[i] == ')') ? "()" : "[]");
		return;
	}
	//如果i与j匹配
	else if (Match(s[i], s[j]) && dp[i][j] == dp[i + 1][j - 1]) {
		//先输出i
		printf("%c", s[i]);
		//再输出中间内容
		Output(i + 1, j - 1);
		//再输出j
		printf("%c", s[j]);
		return;
	}
	else {
		//枚举中转点，寻找最优的分割点（求dp数组时求好的答案）
		for (int k = i; k < j; ++k) {
			//找到某个最优的分割点
			if (dp[i][j] == dp[i][k] + dp[k + 1][j]) {
				//分割输出
				Output(i, k);
				Output(k + 1, j);
				return;
			}
		}
	}
}

AC代码：

#include<iostream>
#include<string>
#include<cstring>
#include<algorithm>
using namespace std;
string s;
int dp[102][102];
bool Input() {
	getline(cin, s);
	getline(cin, s);
	return !s.empty();
}
bool Match(const char& Left, const char& Right) {
	return
		Left == '(' && Right == ')'
		||
		Left == '[' && Right == ']';
}
void DP() {
	memset(dp, 0x3f, sizeof(dp));
	for (int i = 0; i < s.size(); ++i) {
		dp[i + 1][i] = 0;
		dp[i][i] = 1;
	}
	for (int i = s.size() - 2; i >= 0; --i) {
		for (int j = i + 1; j < s.size(); ++j) {
			dp[i][j] = s.size();
			if (Match(s[i],s[j])) {
				dp[i][j] = min(dp[i][j], dp[i + 1][j - 1]);
			}
			for (int k = i; k < j; ++k) {
				dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j]);
			}
		}
	}
}
void Output(int i, int j) {
	if (i > j) {
		return;
	}
	else if (i == j) {
		printf((s[i] == '(' || s[i] == ')') ? "()" : "[]");
		return;
	}
	else if (Match(s[i], s[j]) && dp[i][j] == dp[i + 1][j - 1]) {
		printf("%c", s[i]);
		Output(i + 1, j - 1);
		printf("%c", s[j]);
		return;
	}
	else {
		for (int k = i; k < j; ++k) {
			if (dp[i][j] == dp[i][k] + dp[k + 1][j]) {
				Output(i, k);
				Output(k + 1, j);
				return;
			}
		}
	}
}
int main() {
	int T;
	scanf("%d", &T);
	getchar();
	while (T--) {
		if (!Input()) {
			puts("\n");
			continue;
		}
		DP();
		Output(0, s.size() - 1);
		putchar('\n');
		if (T) {
			putchar('\n');
		}
	}
	return 0;
}