1745. Yet Another Answer

http://acm.timus.ru/problem.aspx?space=1&num=1745

题目大意：

可以是任意的顺序，在满足括号匹配的情况下，求组合成的字符串长度最长

思路：

先将每一个字符串进行处理，处理时将匹配的去掉 比如说  { ）（（）（（））（} 处理后就变成了 {）（  （}

当然字符串的长度是没有变化的 处理后的字符串假如说 左括号的个数为L 右括号的个数为R

我们必须确定一个正确的顺序，可以让我们从头到尾的逐个决定是否选用当前字符串，而且不影响最优结果

字符串有 L>R,L<R 和 L=R 三种情况，对于L>R的字符串要放在前面 因为每一个这样的字符串都可以使

左括号 — 右括号 的值变大，

而对于 L<R 的情况对应放在最后，L=R的情况放在中间

对于L<R的字符串之间 需要把 R 小的放在前面， 对于L>R的情况 要用对称思想去确定顺序

确定顺序之后，剩下的就DP就可以了

代码：

#include<iostream>

#include<stack>

#include<cstdio>

#include<queue>

#include<cstring>

#include<algorithm>

#include<vector>

#include<set>

#include<map>

#include<string>

#include<cmath>



using namespace std;



typedef long long ll;

typedef pair<int,int> pp;

const double eps=1e-9;

const int INF=0x3f3f3f3f;

const int N=1002;

const int M=10002;

struct node

{

    string s;

    int lk,rk;

    int index;

}x[N];

int dp[N][M];

int func(const node& a)

{

    if(a.lk-a.rk>0) return 1;

    if(a.lk-a.rk<0) return -1;

    return 0;

}

bool cmp(const node& a,const node& b)

{

    int lf=func(a),rf=func(b);

    if(lf==1&&rf==1)

    return a.rk<b.rk;

    if(lf==-1&&rf==-1)

    return a.lk>b.lk;

    return lf>rf;

}

int main()

{

    //freopen("data.in","r",stdin);

    int n;

    while(cin>>n)

    {

        for(int i=0;i<n;++i)

        {

            cin>>x[i].s;

            x[i].index=i+1;

            stack<char>st;

            for(unsigned int j=0;j<x[i].s.size();++j)

            {

                if(st.empty()||x[i].s[j]=='('||st.top()==')')

                {

                    st.push(x[i].s[j]);

                }else

                {

                    st.pop();

                }

            }

            x[i].lk=x[i].rk=0;

            while(!st.empty())

            {

                if(st.top()=='(') ++x[i].lk;

                else ++x[i].rk;

                st.pop();

            }

        }

        sort(x,x+n,cmp);



        memset(dp,-1,sizeof(dp));

        dp[0][0]=0;

        for(int i=0;i<n;++i)

        {

            for(int j=0;j<M;++j)

            if(dp[i][j]!=-1)

            {

                dp[i+1][j]=max(dp[i+1][j],dp[i][j]);

                if(j>=x[i].rk)

                dp[i+1][j-x[i].rk+x[i].lk]=max(dp[i+1][j-x[i].rk+x[i].lk],(int)(dp[i][j]+x[i].s.size()));

            }

        }

        vector<int>vt;

        int i=n,j=0;

        while(i>0)

        {

            if(dp[i-1][j]==dp[i][j])

            i=i-1;

            else

            {

                vt.insert(vt.begin(),i-1);

                j=j-x[i-1].lk+x[i-1].rk;i=i-1;

            }

        }

        cout<<dp[n][0]<<" "<<vt.size()<<endl;

        for(unsigned int i=0;i<vt.size();++i)

        {

            if(i>0) cout<<" ";

            cout<<x[vt[i]].index;

        }

        cout<<endl;



    }

    return 0;

}