POJ1141 ZOJ1463 Brackets Sequence 经典动态规划 区间DP

对于这道题目WA的我想说：老子裤子都脱了，你就给我看这个？！ 开始做的时候，随意看了一下案例，就是左右括号可以匹配，题目给的字符串可能不是完全都有匹配的 比如 (([]),这里就是差了一个),应该补全了输出 (([]))

思路还是比较简单的，区间dp,dp[i][j]表示 区间 i 到j之间的匹配数，在这里有特殊情况的 就是 这个区间是一个闭合区间，要判断区间两端的 字符是否可以刚好匹配,若可以匹配 状态转移就多了一个 dp[i][j] = max(dp[i][k]+dp[k+1][j],dp[i+1][j-1]+1),若不能匹配就是dp[i][j] = max(dp[i][j],dp[i][k]+dp[k+1][j]);

若是两端可以匹配的，而且两端匹配了导致的dp值最大那么就标记一下，mark[i][j] = -1,否则 就mark[i][j] = k，这样把所有区间都dp一遍，回头再用DFS寻找，若是两端匹配导致值最大的 那么就直接输出这个字符标记一下，继续往更小的区间去搜索，否则 就分开两个区间搜索 [i,k]        [k+1,j],

由于值区间dp，所以被标记的就是本来就有匹配的，那么直接输出这个字符，否则就输出一对匹配的字符

思路是对的，但是一直WA啊，改 啊改啊，但是还是WA，觉得思路非常清晰也很正确啊，经典的区间DP题目啊，后来看看大牛的博客，发现思路都是一样的啊，没什么区别，搞了两个半小时，实在受不了了，后来发现别人输入用的是getline，我抱着尝试的心态，试了改一下，居然过了，无语，  去看看getline是什么玩意了

#include<iostream>
#include<cstdio>
#include<list>
#include<algorithm>
#include<cstring>
#include<string>
#include<queue>
#include<stack>
#include<map>
#include<vector>
#include<cmath>
#include<memory.h>
#include<set>

#define ll long long

#define eps 1e-7

#define inf 0xfffffff
//const ll INF = 1ll<<61;

using namespace std;

//vector<pair<int,int> > G;
//typedef pair<int,int > P;
//vector<pair<int,int> > ::iterator iter;
//
//map<ll,int >mp;
//map<ll,int >::iterator p;

//#define IN freopen("c:\\Users\\linzuojun\\desktop\\input.txt", "r", stdin)  
//#define OUT freopen("c:\\Users\\linzuojun\\desktop\\output.txt", "w", stdout) 




//
//void TestArray() 
//{
//    char chs[] = {'a', 'd', 'c', 'e', 'b'};
//    int count = sizeof(chs)/sizeof(char);
//    
//    next_permutation(chs+0, chs + count);
//    
//    printf("TestArray:\n");
//    for(int i = 0; i < count; i++) {
//            printf("%c\t", chs[i]);
//    }
//    
//    printf("\n");
//}
//
//void TestVector()
//{
//     char chs[] = {'a', 'd', 'c', 'e', 'b'};
//     int count = sizeof(chs)/sizeof(char);
//     vector<char> vChs(chs, chs + count);
//     
//     next_permutation(vChs.begin(), vChs.end());
//     
//     printf("TestVector:\n");
//     vector<char>::iterator itr;
//     for(itr = vChs.begin(); itr != vChs.end(); itr++) {
//             printf("%c\t", *itr);
//     }
//     printf("\n");
//}
//
//int main(int argc, char *argv[])
//{
//    TestArray();
//    printf("\n");
//    TestVector();
//    
//    system("PAUSE");
//
//	return EXIT_SUCCESS;
//}

int dp[100 + 5][100 + 5];
int mark[100 + 5][100 + 5];
int pos[100 + 5];

void clear() {
	memset(dp,0,sizeof(dp));
	for(int i=0;i<105;i++)
		for(int j=0;j<105;j++)
			mark[i][j] = -2;
	memset(pos,0,sizeof(pos));
}

void dfs(int i,int j) {//倒回去搜索过程超级简单，就是DP过程嘛
	if(mark[i][j] == -1) {//闭区间两头可以匹配
		pos[i] = 1;
		pos[j] = 1;
		dfs(i+1,j-1);
	}
	else if(mark[i][j] >= 0) {
		dfs(i,mark[i][j]);
		dfs(mark[i][j]+1,j);
	}
	else return ;
}

int main() {
	string s;
	while(getline(cin,s)) { 
		clear();
		int i = 0;
		int j = 0;
		int k = 0;
		while(k < s.length()) {
			if(i == j) {
				i++;
				j++;
				if(j == s.length()) {
					i = 0;
					k++;
					j = k;
				}
				continue;
			}
			if((s[i] == '[' && s[j] == ']') || (s[i] == '(' && s[j] == ')')) {//闭区间两头可以匹配
				for(int l=i;l<j;l++) {
					if(dp[i][j] < dp[i][l] + dp[l+1][j]) {
						mark[i][j] = l;
						dp[i][j] = dp[i][l] + dp[l+1][j];
					}
				}
				if(dp[i][j] < dp[i+1][j-1] + 1) {
					mark[i][j] = -1;
					dp[i][j] = dp[i+1][j-1] + 1;
				}
			}
			else {
				for(int l=i;l<j;l++) {
					if(dp[i][j] < dp[i][l] + dp[l+1][j]) {
						mark[i][j] = l;
						dp[i][j] = dp[i][l] + dp[l+1][j];
					}
				}
			}
			i++;
			j++;
			if(j == s.length()) {
				i = 0;
				k++;
				j = k;
			}
		}
		dfs(0,s.length() - 1);
		for(int i=0;i<s.length();i++) {
			if(pos[i] == 1) 
				cout<<s[i];
			else {
				if(s[i] == '(' || s[i]==')')
					cout<<"()";
				else
					cout<<"[]";
			}
		}
		puts("");
	}
	return EXIT_SUCCESS;
}