poj2955 水区间DP

Description
We give the following inductive definition of a “regular brackets” sequence:

the empty sequence is a regular brackets sequence,
if s is a regular brackets sequence, then (s) and [s] are regular brackets sequences, and
if a and b are regular brackets sequences, then ab is a regular brackets sequence.
no other sequence is a regular brackets sequence
For instance, all of the following character sequences are regular brackets sequences:

(), [], (()), ()[], ()[()]

while the following character sequences are not:

(, ], )(, ([)], ([(]

Given a brackets sequence of characters a1a2 … an, your goal is to find the length of the longest regular brackets sequence that is a subsequence of s. That is, you wish to find the largest m such that for indices i1, i2, …, im where 1 ≤ i1 < i2 < … < im ≤ n, ai1ai2 … aim is a regular brackets sequence.

Given the initial sequence ([([]])], the longest regular brackets subsequence is [([])].

Input
The input test file will contain multiple test cases. Each input test case consists of a single line containing only the characters (, ), [, and ]; each input test will have length between 1 and 100, inclusive. The end-of-file is marked by a line containing the word “end” and should not be processed.

Output
For each input case, the program should print the length of the longest possible regular brackets subsequence on a single line.

Sample Input
((()))
()()()
([]])
)[)(
([][][)
end
Sample Output
6
6
4
0
6

这个题的转移其实就是dp[i][j] =max(dp[i+k][j-k-i] )
如果碰到了左括号，那么无论如何不会出现新的匹配，那么就把dp[1-i][j]全部 赋值为dp[1-i][j-1]
如果碰到了右括号，那么就进行一遍dp[i][j] =max(dp[i+k][j-k-i] )
注意！！！
说一下为什么碰到了右中括号不能直接赋值的原因
当a为右中括号的时候。
b的位置可能为左小括号….
这样的话就要漏情况了….
所以这样不行，也要进行一遍转移

#include<iostream>
#include<cmath>
#include<queue>
#include<stack>
#include<algorithm>
#include<cstdio>
#include<string>
#include<memory.h>
using namespace std;
int dp[500][500];
int main()
{
    string q;
    while(cin>>q)
    {
        if(q=="end")break;
        memset(dp,0,sizeof(dp));
        for(int a=0;a<q.size();a++)
        {
            int sum=0;
            if(q[a]=='('||q[a]=='[')
            {
                for(int c=0;c<a;c++)
                {
                    dp[c+1][a+1]=dp[c+1][a-1+1];
                }
            }
            else if(q[a]==']')
            {
                for(int b=a-1;b>=0;b--)
                {
                    if(q[b]!='[')
                    {
                        dp[b+1][a+1]=dp[b+1+1][a+1];
                        //sum=max(dp[1][b]+dp[b+1][a+1],sum);
                        for(int c=a-1;c>=b;c--)
                        {
                            dp[b+1][a+1]=max(dp[b+1][a+1],dp[b+1][c+1]+dp[c+1][a+1]);
                        }
                    }
                    else
                    {
                        dp[b+1][a+1]=dp[b+1+1][a-1+1]+2;
                        for(int c=a-1;c>=b;c--)
                        {
                            dp[b+1][a+1]=max(dp[b+1][a+1],dp[b+1][c+1]+dp[c+1][a+1]);
                        }
                    //  sum=max(dp[1][b]+dp[b+1][a+1],sum);
                    }
                }
            }
            else if(q[a]==')')
            {
                for(int b=a-1;b>=0;b--)
                {
                    if(q[b]!='(')
                    {
                        dp[b+1][a+1]=dp[b+1+1][a+1];
                    //  sum=max(dp[1][b]+dp[b+1][a+1],sum);
                        for(int c=a-1;c>=b;c--)
                        {
                            dp[b+1][a+1]=max(dp[b+1][a+1],dp[b+1][c+1]+dp[c+1][a+1]);
                        }
                    }
                    else
                    {
                        dp[b+1][a+1]=dp[b+1+1][a-1+1]+2;
                        for(int c=a-1;c>=b;c--)
                        {
                            dp[b+1][a+1]=max(dp[b+1][a+1],dp[b+1][c+1]+dp[c+1][a+1]);
                        }
                    }
                }
            }
        }
        cout<<dp[1][q.size()]<<endl;
    }   
    return 0;
}