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;
}

来源：https://www.cnblogs.com/liulangye/p/3349523.html

标签

another