• bzoj 1195: [HNOI2006]最短母串 爆搜


    1195: [HNOI2006]最短母串

    Time Limit: 10 Sec  Memory Limit: 32 MB
    Submit: 894  Solved: 288
    [Submit][Status][Discuss]

    Description

    给定n个字符串(S1,S2,„,Sn),要求找到一个最短的字符串T,使得这n个字符串(S1,S2,„,Sn)都是T的子串。

    Input

    第一行是一个正整数n(n<=12),表示给定的字符串的个数。以下的n行,每行有一个全由大写字母组成的字符串。每个字符串的长度不超过50.

    Output

    只有一行,为找到的最短的字符串T。在保证最短的前提下,如果有多个字符串都满足要求,那么必须输出按字典序排列的第一个。

    Sample Input

    2
    ABCD
    BCDABC

    Sample Output

    ABCDABC
     
     
      本来高高兴兴写了个DP,然而发现根本无法解决字典序问题,怎么办能?
      搜吧。。。。。
      我们假设已经正确地写出了DP,从而得出了答案的长度以及一个字典序不怎么优的解,我们还是dfs枚举顺序,保证当前枚举字符串的字典序小于答案。
      一个强剪枝:如果当前所有没有选的串的“最少选择增加量”之和加上当前字符串长度大于答案直接break
      然后就过了。。。。
      maya,以后这类DP题我都会做了!
     
    #include<iostream>
    #include<cstdio>
    #include<cstring>
    #include<algorithm>
    #include<string>
    #include<vector>
    #include<cassert>
    using namespace std;
    #define MAXN 13
    #define MAXS 55
    #define INF 0x3f3f3f3f
    char str[20][55];
    string res;
    int bstans=INF;
    namespace task1
    {
            string str[MAXN];
            char ss[MAXN][MAXS];
            int len[MAXN];
            int dis[MAXN][MAXN];
            int dp[MAXN][1<<13];
            int rec[MAXN][1<<13][2];
            char res[MAXN*MAXS];
            void deal(int &x,int y)
            {
                    if (x>y)x=y;
            }
            bool cmp_str(const string& s1,const string &s2)
            {
                    for (int i=1;i<=min(s1.length(),s2.length());i++)
                    {
                            if (s1[s1.length()-i]!=s2[s2.length()-i])return s1[s1.length()-i]<s2[s2.length()-i];
                    }
                    return false;
            }
            int main(int n)
            {
                    int m,i,j,k1,k2,k;
                    int x,y;
                    for (i=0;i<n;i++)
                    {
                            str[i]=::str[i];
                    }
                    for (j=0;j<n;j++)
                            for (i=0;i<n;i++)
                                    if (i!=j && str[i].find(str[j])!=-1)
                                    {
                                            swap(str[n-1],str[j]);
                                            str[--n]="";
                                            j--;
                                            break;
                                    }
                    sort(str,&str[n],cmp_str);
                    for (i=0;i<n;i++)
                            len[i]=str[i].length(),strcpy(ss[i],str[i].c_str());
                    //    memset(dis,INF,sizeof(dis));
                    for (i=0;i<n;i++)
                    {
                            for (j=0;j<n;j++)
                            {
                                    if (i==j)continue;
                                    dis[i][j]=len[j];
                                    for (k1=0;k1<len[i];k1++)
                                    {
                                            bool flag=true;
                                            for (k2=0;k2+k1<len[i] && k2<len[j];k2++)
                                            {
                                                    if (ss[i][k1+k2]!=ss[j][k2])
                                                    {
                                                            flag=false;
                                                            break;
                                                    }
                                            }
                                            if (flag)
                                            {
                                                    dis[i][j]=max(0,-(len[i]-k1)+len[j]);
                                                    break;
                                            }
                                    }
                            }
                    }
                    memset(dp,INF,sizeof(dp));
                    for (i=0;i<n;i++)
                            dp[i][1<<i]=len[i];
                    int ii;
                    for (ii=0;ii<n;ii++)
                    {
                            for (k=0;k<n;k++)
                            {
                                    for (j=0;j<(1<<n);j++)
                                    {
                                            if (__builtin_popcount(j)!=ii)continue;
                                            for (i=0;i<n;i++)
                                            {
                                                    if (dp[i][j]==INF)continue;
                                                    if ((j&(1<<k))==0)
                                                    {
                                                            if (dp[k][j|(1<<k)]>dp[i][j]+dis[i][k])
                                                            {
                                                                    dp[k][j|(1<<k)]=dp[i][j]+dis[i][k];
                                                                    rec[k][j|(1<<k)][0]=i;
                                                                    rec[k][j|(1<<k)][1]=j;
                                                            }
                                                    }
                                            }
                                    }
                            }
                    }
                    int ans=INF;
                    for (i=0;i<n;i++)
                            if (ans>dp[i][(1<<n)-1])
                            {
                                    ans=dp[i][(1<<n)-1];
                                    x=i;
                                    y=(1<<n)-1;
                            }
                    vector<int> vec;
                    int xx,yy;
                    for (i=0;i<n;i++)
                    {
                            vec.push_back(x);
                            xx=x;yy=y;
                            x=rec[xx][yy][0];
                            y=rec[xx][yy][1];
                    }
                    for (int i=0;i<vec.size()/2;i++)
                            swap(vec[i],vec[vec.size()-1-i]);
                    strcat(res,ss[vec[0]]);
                    for (i=1;i<vec.size();i++)
                    {
                            strcat(res,ss[vec[i]]+len[vec[i]]-dis[vec[i-1]][vec[i]]);
                    }
                    ::res=res;
                    ::bstans=ans;
            }
    }
    int cst[20][20];
    int len[20];
    bool bad[20];
    string curs;
    int cnt;
    int n;
    bool cmp_pair(pair<char*,int> p1,pair<char*,int> p2)
    {
            return strcmp(p1.first,p2.first)<0;
    }
    int mncst[22];
    int dfs(int now,int status,int tdis,int cnt)
    {
            if (tdis>bstans)return 0;
            if (curs>res)return 0;
            int t=0,ret=1;
            for (int i=0;i<n;i++)
            {
                    if (!(status&(1<<i)))
                    {
                            t+=mncst[i];
                    }
            }
            if (t+tdis>bstans)
                    return 0;
            if (status==(1<<n)-1)
            {
                    if (bstans>tdis)
                    {
                            assert(false);
                            res=curs;
                            bstans=tdis;
                    }else
                    {
                            res=min(res,string(curs));
                    }
                    return 1;
            }
            pair<char *,int> seq[13];
            int tots=0;
            for (int i=0;i<n;i++)
                    if (!(status&(1<<i)))
                            seq[tots++]=make_pair(str[i] + len[i]-cst[now][i],i);
            sort(seq,seq+tots,cmp_pair);
            for (int i=0;i<tots;i++)
            {
                    curs+=str[seq[i].second]+(len[seq[i].second]-cst[now][seq[i].second]);
                    t=dfs(seq[i].second,status|(1<<seq[i].second),tdis+cst[now][seq[i].second],cnt*2/tots);
                    cnt-=t;
                    ret+=t;
                    curs=curs.substr(0,tdis);
                    //if (cnt<=0)break;
            }
            return ret;
    }
    
    int main()
    {
        //    freopen("input.txt","r",stdin);
            int x,y,z;
            scanf("%d",&n);
            for (int i=0;i<n;i++)
            {
                    scanf("%s",str[i]);
                    len[i]=strlen(str[i]);
            }
            task1::main(n);
            for (int i=0;i<n;i++)
            {
                    if (bad[i])continue;
                    for (int j=0;j<n;j++)
                    {
                            if (i==j)continue;
                            for (int k=0;k<len[i];k++)
                            {
                                    bool flag2=false;
                                    for (int k2=0;k+k2<len[i];k2++)
                                    {
                                            if (str[i][k2+k]!=str[j][k2])
                                            {
                                                    break;
                                            }
                                            if (k2==len[j]-1)
                                            {
                                                    flag2=true;
                                                    break;
                                            }
                                    }
                                    if (flag2)
                                            bad[j]=true;
                            }
                    }
            }
            x=0;
            for (int i=0;i<n;i++)
            {
                    if (!bad[i])
                            strcpy(str[x++],str[i]);
            }
            n=x;
            char tmp[55];
            for (int i=0;i<n;i++)
                    for (int j=i;j<n;j++)
                            if (string(str[i])>string(str[j]))
                            {
                                    strcpy(tmp,str[i]);
                                    strcpy(str[i],str[j]);
                                    strcpy(str[j],tmp);
                            }
            for (int i=0;i<n;i++)
                    len[i]=strlen(str[i]);
            for (int i=0;i<n;i++)
            {
                    for (int j=0;j<n;j++)
                    {
                            if (i==j)continue;
                            for (int k=0;k<=len[i];k++)
                            {
                                    bool flag=true;
                                    for (int k2=0;k2+k<len[i];k2++)
                                    {
                                            if (str[i][k2+k]!=str[j][k2])
                                            {
                                                    flag=false;
                                                    break;
                                            }
                                    }
                                    if (flag)
                                    {
                                            cst[i][j]=len[j]-(len[i]-k);
                                            break;
                                    }
                            }
                    }
            }
            for (int i=0;i<n;i++)
            {
                    int x=INF;
                    for (int j=0;j<n;j++)
                    {
                            if (i==j)continue;
                            x=min(x,cst[j][i]);
                    }
                    mncst[i]=x;
            }
            for (int i=0;i<n;i++)
            {
                    curs=str[i];
                    dfs(i,1<<i,len[i],100000000);
            }
            cout<<res<<endl;
    }
  • 相关阅读:
    关于C语言中%p和%X的思考
    multimap员工分组案例
    set容器查找操作使用
    绘制漂亮的思维导图
    [deque容器练习]打分案例
    【LeetCode】1162. 地图分析
    【LeetCode】820. 单词的压缩编码
    【LeetCode】914. 卡牌分组
    【LeetCode】999. 车的可用捕获量
    【LeetCode】3. 无重复字符的最长子串
  • 原文地址:https://www.cnblogs.com/mhy12345/p/4513278.html
Copyright © 2020-2023  润新知