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

最新推荐文章于 2024-10-05 20:01:36 发布
最新推荐文章于 2024-10-05 20:01:36 发布
阅读量93 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/mhy12345/p/4513278.html
版权

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

 

转载于:https://www.cnblogs.com/mhy12345/p/4513278.html

alex151194310
关注
bzoj1195 [HNOI2006]最短母串
Elijahqi
05-28 437
http://www.elijahqi.win/archives/3512 Description 给定n个字符串（S1,S2,„,Sn），要求找到一个最短的字符串T，使得这n个字符串（S1,S2,„,Sn）都是T的子串。 Input 第一行是一个正整数n（n&lt;=12），表示给定的字符串的个数。 以下的n行，每行有一个全由大写字母组成的字符串。每个字符串的长度不超过50. Out...
BZOJ1195 : [HNOI2006]最短母串
weixin_30649859的博客
07-20 74
BZOJ1195 : [HNOI2006]最短母串 用最短方案中字典序最小的字符串包含所有给定字符串 看空间比较小就写状压了 好像直接bfs也行 然而这是一种状压dp的做法 设 f[s][i] 为当前在 AC自动机 上编号为 i 的节点，已选择过的字符串集合为 s 的状态 直接大力转移即可 转移到的第一个选择了全集的 s 的时候直接退出 输出方案 由于要输出方案，需要对每...
BZOJ1195:[HNOI2006]最短母串(AC自动机,BFS)
weixin_33720956的博客
11-27 90
Description 给定n个字符串（S1,S2,„,Sn），要求找到一个最短的字符串T，使得这n个字符串（S1,S2,„,Sn）都是T的子串。 Input 第一行是一个正整数n（n<=12），表示给定的字符串的个数。 以下的n行，每行有一个全由大写字母组成的字符串。每个字符串的长度不超过50. Output 只有一行，为找到的最短的字符串T。在保证最短的前...
bzoj 1195: [HNOI2006]最短母串 （状压dp）
clover_hxy的博客
09-24 1158
1195: [HNOI2006]最短母串 Time Limit: 10 Sec  Memory Limit: 32 MB Submit: 1212  Solved: 405 [Submit][Status][Discuss] Description 给定n个字符串（S1,S2,„,Sn），要求找到一个最短的字符串T，使得这n个字符串（S1,S2,„,Sn）都是T的子串。 Inp
bzoj 1195 [HNOI2006]最短母串
我要吃熊猫
05-25 390
AC自动机+分层图bfs
BZOJ 1195: [HNOI2006]最短母串
月下沙茶树
03-22 835
一看字符串就想到ac自动机是不是没救了 然后决定在AC自动机上做分层图最短路233333333 结果发现极限数据刚好卡时限了QAQ 仔细一想好像每条边的长度都是1哎。 果断BFS 其实DFS应该也可以的吧，而且可以剪枝。 但是我有DFS恐惧症，于是果断选择了BFS。 结果跑得奇慢无比。。。。。。。。 不谈了 我想静静 #include #include #include #in
【BZOJ1195】【HNOI2006】最短母串（AC自动机，状压，BFS）
დ♂Hany01's Blog Space♂ღ
03-09 438
Description click me Solution 考虑建出所有串的AC自动机，然后直接在AC自动机上进行广搜，队列的每个元素存下已经包含了哪几个串（状压）、队列中的前驱元素位置，BFS可以保证字典序最小。 菜得KJ的我居然调了一个晚上？！果然太菜了。。。 Source /************************************************ *...
bzoj 1195: [HNOI2006]最短母串
weixin_30556959的博客
02-10 73
MEL卡空间干嘛。。。 不过代码应该没有问题 /* 建立AC自动机 然后按照字典序跑bfs 直到找到组合要求的字符串 */ #include<queue> #include<cstdio> #include<cstring> #define mp make_pair using namespace std;...
BZOJ1195 HNOI2006最短母串（状压dp）
weixin_30770783的博客
10-17 90
　　按照子串出现的先后考虑。令f[i][j]为已经出现的字符串集合为i，最后一个出现的字符串为j时的最短串长，预处理一下任意两个串的最长重叠长度，转移显然。有点麻烦的是字典序，强行增加代码难度。 　　另一个比较简单的做法是上AC自动机，建出来后类似地令f[i][j]为已经出现的字符串集合为i，在自动机上点j时的最短串长，相当于跑一个最短路，bfs时每次优先选字典序最小的边即可。 #incl...
[BZOJ1195] [HNOI2006]最短母串（状压dp）
zyf2000
09-25 1351
忘记一个人，并非不再想起，而是偶尔想起，心中却不再有波澜。
Bzoj1195——最短母串（AC自动机）
wangyh1008的博客
08-08 802
1195: [HNOI2006]最短母串Time Limit: 10 Sec&nbsp;&nbsp;Memory Limit: 32 MBSubmit: 2037&nbsp;&nbsp;Solved: 689Description给定n个字符串（S1,S2,„,Sn），要求找到一个最短的字符串T，使得这n个字符串（S1,S2,„,Sn）都是T的子串。Input第一行是一个正整数n（n&lt;=12...
BZOJ 3575: [Hnoi2014]道路堵塞
月下沙茶树
04-11 1059
首先我们玩一下会发现删掉一条路之后的最短路一定是原来最短路的一段且仅一段换成了一条非最短路 每一次删边，我们从边的起点出发进行spfa，当spfa到终点往后的最短路上的点时更新一下答案（的集合） 对于答案的集合呢，我们维护以每个点为终点的非最短路的总的长度（即1-p最短路+某个点->p的非最短路+p->n的最短路），这个搞个线段树就好了 然后处理完一条边之后，以这条边的终点为终点的答案全都非
【BZOJ 1193】 [HNOI2006]马步距离
Regina8023
02-27 1976
贪心+bfs 或者 打表找规律（手绘~~）
ACM中常用算法----字符串
码代码的猿猿
07-26 8045
ACM中常用算法—-字符串ACM中常用的字符串算法不多,主要有以下几种: Hash 字典树 KMP AC自动机 manacher 后缀数组 EX_KMP SAM(后缀自动机) 回文串自动机 下面来分别介绍一下:0. Hash字符串的hash是最简单也最常用的算法,通过某种hash函数将不同的字符串分别对应到不同的数字.进而配合其他数据结构或STL可以做到判重,统计,查询等操作. #### 字符串的h
【LeetCode】每日一题 2024_10_5 完成旅途的最少时间（二分答案）
Locky136的博客
10-05 413
【LeetCode】每日一题 2024_10_5 完成旅途的最少时间（二分答案）
编程题 7-14 求整数段和【PAT】
绯樱殇雪的博客
09-30 958
编程题 7-14 求整数段和
Python | Leetcode Python题解之第448题找到所有数组中消失的数字
Mopes__的博客
10-01 414
Python | Leetcode Python题解之第448题找到所有数组中消失的数字
数据结构篇（绪论）
最新发布
wlcass zhengge blog
10-05 432
字符类型：char布尔类型：boolean数值类型：byte、short、int、long、float、double。如果系统自定义的数据类型不够，可以自定义数据类型。例如：Person、Animal、. . .算法（Algorithm）是指解题方案的准确而完整的描述，是一系列解决问题的清晰指令。算法代表着用系统的方法描述解决问题的策略机制。
BZOJ2839:集合计数(容斥,组合数学)
06-08
这个问题是一个比较经典的容斥原理的应用题目。我们可以考虑使用容斥原理来求解这个问题。具体来说，我们可以考虑求出所有集合的个数，然后减去至少包含一个特定元素的集合的个数，再加上至少包含两个特定元素的集合...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值