[HNOI2006]最短母串问题——AC自动机+状压+bfs环形处理

最新推荐文章于 2019-08-27 16:23:47 发布
最新推荐文章于 2019-08-27 16:23:47 发布
阅读量91 收藏
点赞数
原文链接：http://www.cnblogs.com/Miracevin/p/9734949.html
版权

Description

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

32MB

Input

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

Output

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

Sample Input

2
ABCD
BCDABC

Sample Output

ABCDABC
 

Solution

一看是一个AC自动机。

一看是一个状压。

一看AC自动机节点再记录一个has包含的字符串集合。

一看要输出方案，肯定也要先考虑怎么弄出最短的长度。

f[i][(1<<n)-1]表示，匹配到AC自动机上的i点，包含的字符串集合为。。。的最短长度。

一看转移有环，然后无法再加入新的阶段，因为会MLE会TLE

所以要环形处理。

一看是一个取min的do

所以可以考虑最短路。

dij，spfa复杂度卡不过。

一看边权只有1……

BFS大法吼！

长度OK

怎么处理方案？

ywy_c_asm:

一遍bfs求出最短距离len，然后再一遍dfs找方案。

dfs时，相当于再把bfs的最短路怎么来的再访问一遍。如果dis[y]=dis[x]+1那么可以转移的，才可以访问。

还需要知道一个点到终点的最短路。

（反向多起点BFS???不行，或运算不可逆）

我们dfs时就可以实现的。类似树形dp

然后如果一个点到一个(1<<n)-1状态的点距离为juli的话，如果有dis[x]+juli[x]==len，那么，这次选择的这个y，所填的字符，就是最终答案的一个字符。

直接加入答案字符串。

char从A~Z枚举。保证第一次搜到的是字典序最小的。

而且一定是连续加入ans字符串。

dfs开头放上，如果tot==n return；

代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=13;
const int M=600;
const int U=11*50*((1<<12)-1)+100;
const int inf=0x3f3f3f3f;
int n;
char s[55];
struct trie{
    int fail[M],ch[M][26];
    int has[M];
    int cnt;
    void ins(char *s,int l,int id){
        int now=0;
        for(int i=1;i<=l;i++){
            int x=s[i]-'A';
            if(!ch[now][x]) ch[now][x]=++cnt;
            now=ch[now][x];
        }
        has[now]|=(1<<(id-1));
    }
    void build(){
        queue<int>q;
        for(int i=0;i<=25;i++){
            if(ch[0][i]) fail[ch[0][i]]=0,q.push(ch[0][i]);
        }
        while(!q.empty()){
            int x=q.front();q.pop();
            has[x]|=has[fail[x]];
            for(int i=0;i<=25;i++){
                if(ch[x][i]){
                    fail[ch[x][i]]=ch[fail[x]][i];
                    q.push(ch[x][i]);
                }
                else ch[x][i]=ch[fail[x]][i];
            }
        }
    }
}ac;
int get(int ptr,int st){
    return ptr*(1<<n)+st;
}
int dis[U];
bool vis[U];
struct node{
    int P,S;
};
queue<node>q;
void bfs(){
    
    memset(dis,0x3f,sizeof dis);
    int str=get(0,0);
    dis[str]=0;
    vis[str]=1;
    node nn;nn.P=0,nn.S=0;
    q.push(nn);
    while(!q.empty()){
        node lp=q.front();q.pop();
        for(int i=0;i<=25;i++){
            int to=ac.ch[lp.P][i];
            int NS=lp.S|ac.has[ac.ch[lp.P][i]];
            int NID=get(to,NS);
            if(!vis[NID]){
                dis[NID]=dis[get(lp.P,lp.S)]+1;
                vis[NID]=1;
                node kk;
                kk.P=to;kk.S=NS;
                q.push(kk);
            }
        }
    }
}
int len;
int tot;
char ans[M];
int juli[U];
void dfs(int ptr,int st){
    
    int now=get(ptr,st);
    juli[now]=inf;
    
    if(tot==len) return;
    
    if(st==(1<<n)-1) {
        juli[now]=0;return;
    }
    for(int i=0;i<=25;i++){
        int to=ac.ch[ptr][i];
        int NS=st|ac.has[to];
        int NID=get(to,NS);
        if(dis[NID]==dis[now]+1){
            if(!vis[NID]){
                vis[NID]=1;
                dfs(to,NS);
            }
            juli[now]=min(juli[now],juli[NID]+1);
            if(dis[now]+juli[now]==len){
                ans[++tot]='A'+i;return;
            }
        }
    }
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%s",s+1);
        int l=strlen(s+1);
        ac.ins(s,l,i);    
    }
    ac.build();
    bfs();
    len=inf;
    //for(int j=0;j<=(1<<n)-1;j++)
    //for(int i=0;i<=ac.cnt;i++){
    //    cout<<i<<" "<<j<<" : "<<dis[get(i,j)]<<endl;
    //}
    for(int i=0;i<=ac.cnt;i++){
        int id=get(i,(1<<n)-1);
        len=min(len,dis[id]);
    }
    //cout<<" len "<<len<<endl;
    memset(vis,0,sizeof vis);
    memset(juli,0x3f,sizeof juli);
    vis[get(0,0)]=1;
    dfs(0,0);
    //int haha=dfs(0,0);
    for(int i=tot;i>=1;i--){
        printf("%c",ans[i]);
    }
    return 0;
}
1

 

但是不够优美。

为什么要bfs然后再dfs呢？

bfs也可以求前驱啊！！
bfs时，第一更新到的就是最短路。

如果我们char A~Z，那么更新到的char

也就叫from[y]，也就是到y这个点所形成的字典序最小字符串最后一个字符。

记录from，pre（也就是前驱）

bfs后，先找到len

再把所有f[i][(1<<n)-1]的字符找出来，cmp一下。

反正复杂度不超过600*600

代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=13;
const int M=600;
const int U=11*50*((1<<12)-1)+100;
const int inf=0x3f3f3f3f;
int n;
char s[55];
struct trie{
    int fail[M],ch[M][26];
    int has[M];
    int cnt;
    void ins(char *s,int l,int id){
        int now=0;
        for(int i=1;i<=l;i++){
            int x=s[i]-'A';
            if(!ch[now][x]) ch[now][x]=++cnt;
            now=ch[now][x];
        }
        has[now]|=(1<<(id-1));
    }
    void build(){
        queue<int>q;
        for(int i=0;i<=25;i++){
            if(ch[0][i]) fail[ch[0][i]]=0,q.push(ch[0][i]);
        }
        while(!q.empty()){
            int x=q.front();q.pop();
            has[x]|=has[fail[x]];
            for(int i=0;i<=25;i++){
                if(ch[x][i]){
                    fail[ch[x][i]]=ch[fail[x]][i];
                    q.push(ch[x][i]);
                }
                else ch[x][i]=ch[fail[x]][i];
            }
        }
    }
}ac;
int get(int ptr,int st){
    return ptr*(1<<n)+st;
}
int dis[U];
bool vis[U];
struct node{
    int P,S;
};
queue<node>q;
int pre[U];
int from[U];
void bfs(){
    memset(dis,0x3f,sizeof dis);
    int str=get(0,0);
    dis[str]=0;
    vis[str]=1;
    pre[str]=-1;//warning!!
    node nn;nn.P=0,nn.S=0;
    q.push(nn);
    while(!q.empty()){
        node lp=q.front();q.pop();
        for(int i=0;i<=25;i++){
            int to=ac.ch[lp.P][i];
            int NS=lp.S|ac.has[ac.ch[lp.P][i]];
            int NID=get(to,NS);
            if(!vis[NID]){
                dis[NID]=dis[get(lp.P,lp.S)]+1;
                vis[NID]=1;
                from[NID]=i+1;//warning!!!!
                pre[NID]=get(lp.P,lp.S);
                node kk;
                kk.P=to;kk.S=NS;
                q.push(kk);
            }
        }
    }
}
int len;
int tot;
char ans[M];
char a[M];
bool fl;
bool cmp(char *a,char *b){//a better than b?
    for(int i=1;i<=len;i++){
        if(a[i]<b[i]) return 1;
        if(a[i]>b[i]) return 0;
    }
}
int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%s",s+1);
        int l=strlen(s+1);
        ac.ins(s,l,i);    
    }
    ac.build();
    bfs();
    len=inf;
    for(int i=0;i<=ac.cnt;i++){
        int id=get(i,(1<<n)-1);
        len=min(len,dis[id]);
    }
    fl=false;
    //cout<<" len "<<len<<endl;
    for(int i=0;i<=ac.cnt;i++){
        int id=get(i,(1<<n)-1);
        if(dis[id]==len){
            int tmp=len;
            int z=id;
            while(pre[z]!=-1){
                //cout<<z<<endl;
                a[tmp]='A'+(from[z]-1);
                z=pre[z];tmp--;
            }
            if(!fl){
                fl=true;
                memcpy(ans,a,sizeof a);
            }
            else{
                if(cmp(a,ans)) memcpy(ans,a,sizeof a);
            }
        }
    }
    printf("%s",ans+1);
    return 0;
}
2

 

但是还不够优美！！

为什么bfs之后还要再比较一遍字符串呢？？

bfs中，第一次到达一个(1<<n)-1的点,

这个点就一定是最优解的最后一个节点！！！

因为，bfs分层图保证了最短。

for char A~Z保证了字典序最优。

直接输出即可。

代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=13;
const int M=600;
const int U=11*50*((1<<12)-1)+100;
const int inf=0x3f3f3f3f;
int n;
char s[55];
struct trie{
    int fail[M],ch[M][26];
    int has[M];
    int cnt;
    void ins(char *s,int l,int id){
        int now=0;
        for(int i=1;i<=l;i++){
            int x=s[i]-'A';
            if(!ch[now][x]) ch[now][x]=++cnt;
            now=ch[now][x];
        }
        has[now]|=(1<<(id-1));
    }
    void build(){
        queue<int>q;
        for(int i=0;i<=25;i++){
            if(ch[0][i]) fail[ch[0][i]]=0,q.push(ch[0][i]);
        }
        while(!q.empty()){
            int x=q.front();q.pop();
            has[x]|=has[fail[x]];
            for(int i=0;i<=25;i++){
                if(ch[x][i]){
                    fail[ch[x][i]]=ch[fail[x]][i];
                    q.push(ch[x][i]);
                }
                else ch[x][i]=ch[fail[x]][i];
            }
        }
    }
}ac;
int get(int ptr,int st){
    return ptr*(1<<n)+st;
}
int dis[U];
bool vis[U];
struct node{
    int P,S;
};
queue<node>q;
int pre[U];
int from[U];
int len;
char ans[M];
void bfs(){
    memset(dis,0x3f,sizeof dis);
    int str=get(0,0);
    dis[str]=0;
    vis[str]=1;
    pre[str]=-1;//warning!!
    node nn;nn.P=0,nn.S=0;
    q.push(nn);
    while(!q.empty()){
        node lp=q.front();q.pop();
        for(int i=0;i<=25;i++){
            int to=ac.ch[lp.P][i];
            int NS=lp.S|ac.has[ac.ch[lp.P][i]];
            int NID=get(to,NS);
            if(!vis[NID]){
                dis[NID]=dis[get(lp.P,lp.S)]+1;
                vis[NID]=1;
                from[NID]=i+1;//warning!!!!
                pre[NID]=get(lp.P,lp.S);
                node kk;
                kk.P=to;kk.S=NS;
                q.push(kk);
                if(NS==(1<<n)-1){
                    int z=NID;
                    while(pre[z]!=-1){
                        ans[++len]='A'+(from[z]-1);
                        z=pre[z];
                    }
                    return;
                }
            }
        }
    }
}

int main(){
    scanf("%d",&n);
    for(int i=1;i<=n;i++){
        scanf("%s",s+1);
        int l=strlen(s+1);
        ac.ins(s,l,i);    
    }
    ac.build();
    bfs();
    for(int i=len;i>=1;i--) printf("%c",ans[i]);
    return 0;
}
3

 

总结：

有的时候我们只关心最优答案。

但有的时候我们也关心方案。（毕竟知道方案比较实用）

方案的输出就要求高了一些。

但是肯定也是在最优答案的基础上的。

关于路径转移，凑字典序最小，经常通过松弛最优解的顺序，恰好可以保证松弛路径就是最小字典序。

本题就是一个很好的例子。

 

转载于:https://www.cnblogs.com/Miracevin/p/9734949.html

weixin_34088598
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
HNOI2014数据+所有程序
10-07
HNOI2014,数据，程序，评测包，省选，NOI，NOIP，各省省选
[HNOI2006]最短母串问题
a6t2007的博客
11-24 198
题目大意： 求包含n个串的长度最短，且字典序最小的串。 题解： AC自动机/Trie图 + bfs。 我用的是Trie图。 把所有串扔到Trie树上，Trie图建fail指针。 然后的bfs搜索路径。 遍历时从小到大，可以保证字典序最小。 状态中压入各个子串出现过/为出现过。 代码： #include<queue> #include<cstdi...
2782: [HNOI2006]最短母串
weixin_30240349的博客
04-08 98
2782: [HNOI2006]最短母串 Time Limit:1 SecMemory Limit:128 MBSubmit:3Solved:2[Submit][Status][Web Board] Description 给定n个字符串（S1,S2,„,Sn），要求找到一个最短的字符串T，使得这n个字符串（S1,S2,„,Sn）都是T的子串。 Input 第一行是一...
HNOI2006 最短母串问题
a6t2007的博客
11-30 90
题目描述： 题解： 先见出Trie图，然后bfs出所有状态。 我们按照字典序遍历，只要找到合法串直接跳出。这样可以保证长度最小+字典序最小。 代码： #include<queue> #include<cstdio> #include<cstring> #include<algorithm> using namesp...
洛谷P2322 [HNOI2006]最短母串问题
ACoder
03-14 596
BFS、状压DP、AC自动机
HNOI2018训练.rar
02-05
信息学竞赛2003年~2017年部分各省省选试题及NOI试题AC代码，包括但不限于： [NOI2003]文本编辑器(Treap) [JSOI2004]平衡点(模拟退火) [JSOI2004]平衡点(正交分解) [NOI2005]维护数列 [POI2007]ZAP-Queries [HAOI...
HNOI2014题解及数据
05-14
HNOI2014题解及数据，包括标程及试题
Luogu P2278 [HNOI2003]操作系统
01-20
对于操作系统，我们只拥有一个CPU，只能同时处理一个任务。现在有很多任务需要操作系统解决，它们将按照产生时间输入。 每个任务都需要一定时间完成，并且每个任务都有一个优先级和产生时间。当它们产生时，如果CPU...
HNOI2004 高精度开根
最新发布
08-23
[HNOI2004] 高精度开根代码
最短母串问题（AC自动机+BFS+状态压缩）
UniverseofHK的博客
08-27 396
最短母串问题 题意：给定nnn个子串，求最短且字典序最小的母串（母串性质：这nnn个子串都包含在母串里） 思路： 考虑把子串去重（不去重能不能A我不知道，但去重肯定没问题） 建好AC自动机 从000节点开始用bfsbfsbfs遍历自动机，并且总是从’A’遍历到’Z’以保证答案的字典序最下 每次取出头结点时检查其状态是否包含了所有的子串，状态检查：now.state==(1&lt;&amp...
题解 luoguP2322 【[HNOI2006]最短母串问题】
lxy超超超级大蒟蒻的博客
05-06 233
传送门 看到n&lt;=12n&lt;=12n<=12的数据范围，一眼状压dp​dp​dp​？随便开始敲了敲，一晚上就没了？ 看到题解还有一篇状压，感觉挺麻烦的。这里给出可能稍微方便一点的。 状压状态和方程应该很好想，f[i][j]f[i][j]f[i][j]表示状态iii下，最后的字符串是jjj的最短长度，因为要输出方案，再来一个g[i][j]g[i][j]g[i][j]表...
[HNOI2006]最短母串问题（AC自动机+状态压缩+bfs）
weixin_30267697的博客
05-20 86
快要THUSC了，来水几道模板题吧。 这题其实是AC自动机模板。看到长度最短，首先就想到AC自动机。那么就直接暴力法来吧，把每个串建立在AC自动机上，建立fail指针，然后由于n<=12，可以把记录的状态压缩一下，就是压缩走到该节点出现了哪些状态，建立fail指针时也顺带更新一下。然后直接从根节点开始bfs，即可求出状态，复杂度O(26*2^n*Σ|S|)，注意内存是32MB，而...
大视野1195: [HNOI2006]最短母串
Druning的博客
03-19 1002
题目 Description 给定n个字符串(S1,S2,„,Sn)，要求找到一个最短的字符串T，使得这n个字符串(S1,S2,„,Sn)都是T的子串。 Input 第一行是一个正整数n(n Output 只有一行，为找到的最短的字符串T。在保证最短的前提下，如果有多个字符串都满足要求，那么必须输出按字典序排列的第一个。 题意 题意非常简单，就是题目第一行。
bzoj1195: [HNOI2006]最短母串
miaom的博客
12-07 610
一开始以为这是字符串好题，一看n范围，n！就炸了。 考虑dp，dp[i][j] i表示每个子串有没有出现，j表示最后的串。 看了lych的博客之后，自己还是naive！首先有可能出现一个串没有用，要预处理掉，另外字典序最小需要存更多的东西。复杂度O（2^n*n*n*跑得过）。 #include #include #include #define N 13 using namespace s
BZOJ 1195: [HNOI2006]最短母串
月下沙茶树
03-22 818
一看字符串就想到ac自动机是不是没救了 然后决定在AC自动机上做分层图最短路233333333 结果发现极限数据刚好卡时限了QAQ 仔细一想好像每条边的长度都是1哎。 果断BFS 其实DFS应该也可以的吧，而且可以剪枝。 但是我有DFS恐惧症，于是果断选择了BFS。 结果跑得奇慢无比。。。。。。。。 不谈了 我想静静 #include #include #include #in
bzoj1195 [HNOI2006]最短母串（ACAM+状压+bfs）
Icefox的博客
05-28 269
建出ACAM，然后装压到每个点的串匹配状态。 最短的字典序最小的，于是我们贪心地从小到大bfs。 复杂度O(nm2n)O(nm2n)O(nm2^n) 这题卡内存真是酸爽【再见】 #include &lt;bits/stdc++.h&gt; using namespace std; #define ll long long #define inf 0x3f3f3f3f #define N 6...
【bzoj1195】[HNOI2006]最短母串
wzf_2000的博客
08-05 391
此题似乎是一个dp。。 dp[i][j]表示选了i这个集合的字符串，最后一个是j的最短字符串。 （字典序顺便搞定） 然后发现需要处理掉一串为另一串子串的情况，特判一些特殊情况（或者奇怪的姿势）就好了。。 这题很卡空间，请务必不要乱开数组。#include <bits/stdc++.h> #define gc getchar() using namespace std; int n,len[1
P3722 [AH2017/HNOI2017] 影魔
07-28
- *1* *3* [P3722 [AH2017/HNOI2017]影魔（树状数组）](https://blog.csdn.net/li_wen_zhuo/article/details/115446022)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值