BZOJ 1195 [HNOI2006]最短母串 (Trie图+状压+bfs最短路)

BZOJ1195 LOJ10061

题目大意：给你$n$个模式串，求一个最短且字典序最小的文本串并输出这个串，$n<=12,len<=50$

首先对所有模式串构造$Trie$图，$Trie$图的性质和$DP$的性质简直是完美契合..

模式串数量很少，考虑状压

定义$f[x][s]$表示现在所在$Trie$图内的位置为$x$，已经匹配到的串的状态为$s$，此时需要文本串的最短长度

转移十分显然，$f[fail_{x}][s|ed[fail_{x}])]=min(f[x][s])+1$

最后找出最小的$f[x][(1<<n)-1]$

然而...直接这样转移我们没办法统计答案啊

考虑把问题放到图上，利用$bfs$队列先进先出的性质，如果我们优先把字典序小的状态推进队列，再通过记录当前状态第一次被更新时的上一层状态$fa[..]$的方式记录路径，跑$bfs$最短路，当队列中出现$s==(1<<n)-1$时立即结束，此时我们求得的一定是长度最短且字典序最小的答案！

注意可能有相同的串

注意不要忘了建$fail$树，如果某个节点是某个串的结尾，也要把它是这个串的结尾的信息传递到它在$fail$树中的子树中去！我没传竟然还有70分

 #include <queue>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #define NN 610
 #define MM 4100
 #define ll long long
 #define uint unsigned int
 #define ull unsigned long long
 #define inf 0x3f3f3f3f
 #define idx(x) (x-'A')
 using namespace std;

 int n,cte;
 int head[NN];
 char str[NN];
 struct Edge{int to,nxt;}edge[NN*];
 void ae(int u,int v){
     cte++;edge[cte].nxt=head[u];
     edge[cte].to=v,head[u]=cte;
 }
 struct node{
     int x,s;
     node(int x,int s):x(x),s(s){}
     node(){}
 }fa[NN][MM];
 int dis[NN][MM];
 namespace AC{
 int ch[NN][],fail[NN],ed[NN],val[NN],tot;
 void Build_Trie(char *str,int len,int id)
 {
     int x=;
     for(int i=;i<=len;i++){
         if(!ch[x][idx(str[i])])
             ch[x][idx(str[i])]=++tot,val[tot]=idx(str[i]);
         x=ch[x][idx(str[i])];
     }ed[x]|=(<<(id-));
 }
 void Build_Fail()
 {
     queue<int>q;
     for(int i=;i<;i++)
         if(ch[][i]) q.push(ch[][i]);
     while(!q.empty())
     {
         int x=q.front();q.pop();
         ae(fail[x],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];
             }
         }
     }
     q.push();
     while(!q.empty())
     {
         int x=q.front();q.pop();
         for(int j=head[x];j;j=edge[j].nxt){
             int v=edge[j].to;
             ed[v]|=ed[x];
             q.push(v);
         }
     }
 }
 node Bfs()
 {
     queue<node>q;
     memset(dis,0x3f,sizeof(dis));
     q.push(node(,));
     dis[][]=;
     node k1,k2;
     int x,v,s,t;
     while(!q.empty())
     {
         k1=q.front();q.pop();
         x=k1.x,s=k1.s;
         if(s==(<<n)-) return k1;
         for(int i=;i<;i++)
         {
             v=ch[x][i],t=s|ed[v];
             if(dis[v][t]>dis[x][s]+){
                 dis[v][t]=dis[x][s]+;
                 fa[v][t]=k1;
                 q.push(node(v,t));
             }
         }
     }
     /*for(int i=1;i<=tot;i++)
         printf("%d:%d\n",i,dis[i][(1<<n)-1]);*/
 }
 char Ans[NN];
 void solve()
 {
     for(int i=;i<=n;i++){
         scanf("%s",str+);
         int len=strlen(str+);
         Build_Trie(str,len,i);}
     Build_Fail();
     node ans=Bfs();
     node a=ans;
     int num=;
     while(a.x||a.s){
         Ans[++num]=val[a.x]+'A';
         a=fa[a.x][a.s];}
     for(int i=num;i>;i--)
         printf("%c",Ans[i]);
     puts("");
 }
 };

 int main()
 {
     //freopen("t2.in","r",stdin);
     scanf("%d",&n);
     AC::solve();
     return ;
 }