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

const int M=;

const int U=**((<<)-)+;

const int inf=0x3f3f3f3f;

int n;

char s[];

struct trie{

    int fail[M],ch[M][];

    int has[M];

    int cnt;

    void ins(char *s,int l,int id){

        int now=;

        for(int i=;i<=l;i++){

            int x=s[i]-'A';

            if(!ch[now][x]) ch[now][x]=++cnt;

            now=ch[now][x];

        }

        has[now]|=(<<(id-));

    }

    void build(){

        queue<int>q;

        for(int i=;i<=;i++){

            if(ch[][i]) fail[ch[][i]]=,q.push(ch[][i]);

        }

        while(!q.empty()){

            int x=q.front();q.pop();

            has[x]|=has[fail[x]];

            for(int i=;i<=;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*(<<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(,);

    dis[str]=;

    vis[str]=;

    node nn;nn.P=,nn.S=;

    q.push(nn);

    while(!q.empty()){

        node lp=q.front();q.pop();

        for(int i=;i<=;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)]+;

                vis[NID]=;

                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==(<<n)-) {

        juli[now]=;return;

    }

    for(int i=;i<=;i++){

        int to=ac.ch[ptr][i];

        int NS=st|ac.has[to];

        int NID=get(to,NS);

        if(dis[NID]==dis[now]+){

            if(!vis[NID]){

                vis[NID]=;

                dfs(to,NS);

            }

            juli[now]=min(juli[now],juli[NID]+);

            if(dis[now]+juli[now]==len){

                ans[++tot]='A'+i;return;

            }

        }

    }

}

int main(){

    scanf("%d",&n);

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

        scanf("%s",s+);

        int l=strlen(s+);

        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=;i<=ac.cnt;i++){

        int id=get(i,(<<n)-);

        len=min(len,dis[id]);

    }

    //cout<<" len "<<len<<endl;

    memset(vis,,sizeof vis);

    memset(juli,0x3f,sizeof juli);

    vis[get(,)]=;

    dfs(,);

    //int haha=dfs(0,0);

    for(int i=tot;i>=;i--){

        printf("%c",ans[i]);

    }

    return ;

}

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

const int M=;

const int U=**((<<)-)+;

const int inf=0x3f3f3f3f;

int n;

char s[];

struct trie{

    int fail[M],ch[M][];

    int has[M];

    int cnt;

    void ins(char *s,int l,int id){

        int now=;

        for(int i=;i<=l;i++){

            int x=s[i]-'A';

            if(!ch[now][x]) ch[now][x]=++cnt;

            now=ch[now][x];

        }

        has[now]|=(<<(id-));

    }

    void build(){

        queue<int>q;

        for(int i=;i<=;i++){

            if(ch[][i]) fail[ch[][i]]=,q.push(ch[][i]);

        }

        while(!q.empty()){

            int x=q.front();q.pop();

            has[x]|=has[fail[x]];

            for(int i=;i<=;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*(<<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(,);

    dis[str]=;

    vis[str]=;

    pre[str]=-;//warning!!

    node nn;nn.P=,nn.S=;

    q.push(nn);

    while(!q.empty()){

        node lp=q.front();q.pop();

        for(int i=;i<=;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)]+;

                vis[NID]=;

                from[NID]=i+;//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=;i<=len;i++){

        if(a[i]<b[i]) return ;

        if(a[i]>b[i]) return ;

    }

}

int main(){

    scanf("%d",&n);

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

        scanf("%s",s+);

        int l=strlen(s+);

        ac.ins(s,l,i);

    }

    ac.build();

    bfs();

    len=inf;

    for(int i=;i<=ac.cnt;i++){

        int id=get(i,(<<n)-);

        len=min(len,dis[id]);

    }

    fl=false;

    //cout<<" len "<<len<<endl;

    for(int i=;i<=ac.cnt;i++){

        int id=get(i,(<<n)-);

        if(dis[id]==len){

            int tmp=len;

            int z=id;

            while(pre[z]!=-){

                //cout<<z<<endl;

                a[tmp]='A'+(from[z]-);

                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+);

    return ;

}

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

const int M=;

const int U=**((<<)-)+;

const int inf=0x3f3f3f3f;

int n;

char s[];

struct trie{

    int fail[M],ch[M][];

    int has[M];

    int cnt;

    void ins(char *s,int l,int id){

        int now=;

        for(int i=;i<=l;i++){

            int x=s[i]-'A';

            if(!ch[now][x]) ch[now][x]=++cnt;

            now=ch[now][x];

        }

        has[now]|=(<<(id-));

    }

    void build(){

        queue<int>q;

        for(int i=;i<=;i++){

            if(ch[][i]) fail[ch[][i]]=,q.push(ch[][i]);

        }

        while(!q.empty()){

            int x=q.front();q.pop();

            has[x]|=has[fail[x]];

            for(int i=;i<=;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*(<<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(,);

    dis[str]=;

    vis[str]=;

    pre[str]=-;//warning!!

    node nn;nn.P=,nn.S=;

    q.push(nn);

    while(!q.empty()){

        node lp=q.front();q.pop();

        for(int i=;i<=;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)]+;

                vis[NID]=;

                from[NID]=i+;//warning!!!!

                pre[NID]=get(lp.P,lp.S);

                node kk;

                kk.P=to;kk.S=NS;

                q.push(kk);

                if(NS==(<<n)-){

                    int z=NID;

                    while(pre[z]!=-){

                        ans[++len]='A'+(from[z]-);

                        z=pre[z];

                    }

                    return;

                }

            }

        }

    }

}

int main(){

    scanf("%d",&n);

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

        scanf("%s",s+);

        int l=strlen(s+);

        ac.ins(s,l,i);

    }

    ac.build();

    bfs();

    for(int i=len;i>=;i--) printf("%c",ans[i]);

    return ;

}

3

总结：

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

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

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

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

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

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

[HNOI2006]最短母串问题——AC自动机+状压+bfs环形处理的更多相关文章

  1. [HNOI2006]最短母串问题 --- AC自动机 + 隐式图搜索

    [HNOI2006]最短母串问题 题目描述: 给定n个字符串(S1,S2.....,Sn),要求找到一个最短的字符串T,使得这n个字符串(S1,S2,......,Sn)都是T的子串. 输入格式: 第 ...

  2. [bzoj1195][HNOI2006]最短母串_动态规划_状压dp

    最短母串 bzoj-1195 HNOI-2006 题目大意:给一个包含n个字符串的字符集,求一个字典序最小的字符串使得字符集中所有的串都是该串的子串. 注释:$1\le n\le 12$,$1\le ...

  3. [HNOI2006]最短母串问题 AC自动机

    题面:洛谷 题解: 如果我们对这些小串建出AC自动机,那么我们所求的大串就是要求满足遍历过所有AC自动机上的叶子节点,且经过步数最少的串.如果有多个步数相同的串,要输出字典序最小的串. 在AC自动机上 ...

  4. [BZOJ1195]:[HNOI2006]最短母串（AC自动机+BFS）

    题目传送门 题目描述 给定n个字符串(S1,S2,…,Sn),要求找到一个最短的字符串T,使得这n个字符串(S1,S2,…,Sn)都是T的子串. 输入格式 第一行是一个正整数n,表示给定的字符串的个数 ...

  5. bzoj1195 [HNOI2006]最短母串 AC 自动机+状压+bfs

    题目传送门 https://lydsy.com/JudgeOnline/problem.php?id=1195 题解 建立 AC 自动机,然后构建出 trie 图. 然后直接在 trie 图上走.但是 ...

  6. P2322 [HNOI2006]最短母串问题

    P2322 [HNOI2006]最短母串问题 AC自动机+bfs 题目要求:在AC自动机建的Trie图上找到一条最短链,包含所有带结尾标记的点 因为n<12,所以我们可以用二进制保存状态:某个带 ...

  7. BZOJ_1195_[HNOI2006]最短母串_AC自动机+BFS+分层图

    BZOJ_1195_[HNOI2006]最短母串_AC自动机+BFS+分层图 Description 给定n个字符串(S1,S2,„,Sn),要求找到一个最短的字符串T,使得这n个字符串(S1,S2, ...

  8. 【状态压缩dp】1195: [HNOI2006]最短母串

    一个清晰的思路就是状压dp:不过也有AC自动机+BFS的做法 Description 给定n个字符串(S1,S2,„,Sn),要求找到一个最短的字符串T,使得这n个字符串(S1,S2,„,Sn)都是T ...

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

    1195: [HNOI2006]最短母串 Time Limit: 10 Sec  Memory Limit: 32 MBSubmit: 894  Solved: 288[Submit][Status] ...

随机推荐

  1. [转载]linux+nginx+python+mysql安装文档

    原文地址:linux+nginx+python+mysql安装文档作者:oracletom # 开发包(如果centos没有安装数据库服务,那么要安装下面的mysql开发包) MySQL-devel- ...

  2. 袋鼠云研发手记 | 袋鼠云EasyManager的TypeScript重构纪要

    作为一家创新驱动的科技公司,袋鼠云每年研发投入达数千万,公司80%员工都是技术人员,袋鼠云产品家族包括企业级一站式数据中台PaaS数栈.交互式数据可视化大屏开发平台Easy[V]等产品也在迅速迭代.在 ...

  3. Python基础灬异常

    异常&异常处理 异常!=错误 在程序运行过程中,总会遇到各种各样的错误. 有的错误是程序编写有问题造成的,比如本来应该输出整数结果输出了字符串,这种错误我们通常称之为bug,bug是必须修复的 ...

  4. C#判断字符串中是否有数字

    // <summary> /// 提取字符串中的数字字符串 /// </summary> /// <param name="str"></ ...

  5. HttpServlet 详解（基础）

    HttpServlet详解 大家都知道Servlet,但是不一定很清楚servlet框架,这个框架是由两个Java包组成:javax.servlet和javax.servlet.http. 在java ...

  6. ES6的新特性（12）——Set 和 Map 数据结构

    Set 和 Map 数据结构 Set 基本用法 ES6 提供了新的数据结构 Set.它类似于数组,但是成员的值都是唯一的,没有重复的值. Set 本身是一个构造函数,用来生成 Set 数据结构. co ...

  7. php-fpm配置

    [global] error_log = /letv/log/php-fpm_error.log [www] user = apache group = apache listen = 127.0.0 ...

  8. PHPDoc 学习记录

    https://zh.wikipedia.org/wiki/PHPDoc PHPDoc 是一个 PHP 版的 Javadoc.它是一种注释 PHP 代码的正式标准.它支持通过类似 phpDocumen ...

  9. 动态规划——最长公共子序列LCS及模板

    摘自 https://www.cnblogs.com/hapjin/p/5572483.html 这位大佬写的对理解DP也很有帮助,我就直接摘抄过来了,代码部分来自我做过的题 一,问题描述 给定两个字 ...

  10. 第五次作业psp

    psp 进度条 代码累积折线图 博文累积折线图 psp饼状图 团体合作体会:经过这几天的团队,我感受良多.发现团队协作是一件非常让人兴奋的事情.团队成员们互相帮助,互相协作,让我感受最深的就是当自己为 ...