[BZOJ1559]密码 AC自动机+状压

问题 K: [JSOI2009]密码

时间限制: 1 Sec  内存限制: 64 MB

题目描述

众所周知，密码在信息领域起到了不可估量的作用。对于普通的登陆口令，唯一的破解 方法就是暴力破解一逐个尝试所有可能的字母组合，但这是一项很耗时又容易被发现的工 作。所以，为了获取对方的登陆口令，在暴力破解密码之前，必须先做大量的准备工作。经 过情报的搜集，现在得到了若干有用信息，形如：

“我观察到，密码中含有字符串***。”

例如，对于一个10位的密码以及观察到的字符串hello与world,可能的密码组合为 helloworld与worldhello;而对于6位的密码以及观察到的字符串good与day,可能的 密码组合为gooday。

有了这些信息，就能够大大地减少尝试的次数了。请编一个程序，计算所有密码组合的 可能。密码中仅可能包含a - z之间的小写字母。

输入

输入数据首先输入两个整数L,N，分别表示密码的长度与观察到子串的个数。

接下来N行，每行若干个字符，描述了每个观察到的字符串。

输出

输出数据第一行为一个整数，代表了满足所有观察条件字符串的总数。

若这个数字小于等于42,则按字典顺序输出所有密码的可能情况，每行一个，

否则，只输出满足所有观察条件字符串的总数即可。

样例输入

10 2
hello
world

样例输出

2
helloworld
worldhello

提示

对于100%的数据，1<=L<=25，1<=N<=10,每个观察到的字符串长不超过10,并且保 证输出结果小于2^63。

好久没打AC自动机上的DP了……我怎么什么题都不会做啊.jpg

这道题是我今天刷到的比较好的一道题……不仅考到了dp，还考到了搜索基本功。

我们首先考虑：对于串i和j，如果j是i的子串，那么我们根本不用考虑最初单独插入进来的j串，

因为只要i串存在，j串就一定存在

那么我们可以在构建出AC自动机之后，把每个节点从fail指针能达到的节点都设为”不是单词节点“，最后再给单词节点重新编号即可。

那么接下来，我们考虑dp的过程。由于节点数，串数和串长都很小，所以我们考虑状态压缩来解决这个问题。

我们定义状态数组f[i][j][k]表示当前串长为i，位于j号节点，模式串出现情况为k的方案数。

（这种"走i步到达j节点”也是AC自动机上的常见套路之一）

那么我们事先把单词节点对应的串用二进制压好，转移到时候我们只需要这样处理即可：

f[i+1][rt->ch[u]->id][k|rt->ch[u]->val]+=f[i][j][k]

这样我们就可以搜出方案数，接下来我们考虑输出小于42的具体方案。

首先我们可以得到一个性质：若总方案树不超过42，那么最终串一定仅由给定串拼接而成。

因为如果随机字母可以存在，哪怕只有1个模式串，并且仅有1个随机字母，合法方案数在这种最小情况下也有2×26=52(>42)个

因此我们只需要用搜索进行一个dp的逆过程，看合法方案由哪个节点转移过来，并且记录一路上经过的字符，最后排序输出即可。

这真是一道很不错的题目，方式以及套路很经典，对于状压和搜索的应用都很灵活！

(Ps:我还打了一种利用状压从而不用去重的打法，放在最下面）

去重版代码见下：

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 using namespace std;
 const int N=,L=,K=(<<)+;
 typedef long long LL;
 short l,n,len[N],bin[N],tot,cnt,num;
 char s[N][N];
 struct node
 {
     node *ch[],*f;short id,st,meaning;
     node(){memset(ch,,sizeof(ch)),st=,id=++cnt;}
 }*null,*root,*q[N*N],*data[N*N];
 inline node* newnode()
     {node *o=new node();data[cnt]=o;return o;}
 inline void add(int x)
 {
     node *rt=root;register int i,d;
     for(i=;i<len[x];++i)
     {
         d=s[x][i]-'a';
         if(!rt->ch[d])rt->ch[d]=newnode();
         rt=rt->ch[d],rt->meaning=d;
     }
     rt->st=;
 }
 inline void get_fail()
 {
     register int i,hd=,tl=;
     node *rt,*u;
     for(i=,root->f=root;i<;++i)
         if(root->ch[i])root->ch[i]->f=root,q[++tl]=root->ch[i];
         else root->ch[i]=root;
     while(hd<=tl)
         for(rt=q[hd++],u=rt->f,i=;i<;++i)
             if(rt->ch[i])rt->ch[i]->f=u->ch[i],q[++tl]=rt->ch[i];
             else rt->ch[i]=u->ch[i];
     for(i=;i<=cnt;++i)for(u=data[i]->f;u&&u!=null&&u!=root;u=u->f)u->st=;
     for(i=;i<=cnt;++i)if(data[i]->st)data[i]->st=++num;
     for(i=;i<=cnt;++i)if(data[i]->st)data[i]->st=bin[num-data[i]->st];
 }
 LL f[L][N*N][K];
 struct sol
 {
     char s[L];
     sol(){memset(s,,sizeof(s));}
     inline void print(){puts(s);}
     inline bool operator < (const sol &b) const
     {
         for(register int i=;i<l;++i)
             if(s[i]!=b.s[i])return s[i]<b.s[i];
     }
 }str[],stack;
 void dfs(int len,int id,int state,int now)
 {
     register int i,j,k,st;
     stack.s[len-]=now+'a';
     if(len==){str[++tot]=stack;return;}
     for(j=;j<=cnt;++j)
         if(f[len-][j][state]&&data[j]->ch[now]->id==id)
             dfs(len-,j,state,data[j]->meaning);
     if(data[id]->st)
         for(st=state^data[id]->st,j=;j<=cnt;++j)
             if(f[len-][j][st]&&data[j]->ch[now]->id==id)
                 dfs(len-,j,st,data[j]->meaning);
 }
 inline void get_solution()
 {
     register int i,j;tot=;
     for(j=;j<=cnt;++j)
         if(f[l][j][bin[num]-])
             dfs(l,j,bin[num]-,data[j]->meaning);
 }
 int main()
 {
     scanf("%d%d",&l,&n);root=newnode();
     register int i,j,k,u,v;node *rt;LL ans=;
     bin[]=;for(i=;i<=n;++i)bin[i]=bin[i-]<<;
     for(i=;i<=n;++i)scanf("%s",s[i]),len[i]=strlen(s[i]),add(i);
     get_fail();
     for(i=,f[][][]=;i<l;++i)
         for(j=;j<=cnt;++j)
             for(rt=data[j],k=;k<bin[num];++k)
                 if(f[i][j][k])for(u=;u<;++u)
                     f[i+][rt->ch[u]->id][k|rt->ch[u]->st]+=f[i][j][k];
     for(j=;j<=cnt;++j)ans+=f[l][j][bin[num]-];
     printf("%lld\n",ans);
     if(ans<=)
     {
         get_solution();sort(str+,str+ans+);
         for(i=;i<=ans;++i)str[i].print();
     }
 }

不去重打法：

 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 using namespace std;
 const int N=,L=,K=(<<)+;
 typedef long long LL;
 short l,n,len[N],bin[N],cnt,tot,num;
 char s[N][N];
 struct node
 {
     node *ch[],*f,*fa;short id,st,meaning;
     node(){memset(ch,,sizeof(ch)),st=,id=++cnt;}
 }*root,*q[N*N],*data[N*N];
 inline node* newnode()
     {node *o=new node();data[cnt]=o;return o;}
 inline void add(int x)
 {
     node *rt=root;register int i,d;
     for(i=;i<len[x];++i)
     {
         d=s[x][i]-'a';
         if(!rt->ch[d])rt->ch[d]=newnode();
         rt->ch[d]->fa=rt,rt=rt->ch[d],rt->meaning=d;
     }
     rt->st|=bin[n-x];
 }
 inline void get_fail()
 {
     register int i,hd=,tl=;
     node *rt,*u;root->f=root;
     for(i=;i<;++i)
         if(root->ch[i])
             root->ch[i]->f=root,q[++tl]=root->ch[i];
         else root->ch[i]=root;
     while(hd<=tl)
         for(rt=q[hd++],u=rt->f,i=;i<;++i)
             if(rt->ch[i])
                 rt->ch[i]->f=u->ch[i],q[++tl]=rt->ch[i],
                 rt->ch[i]->st|=rt->ch[i]->f->st;
             else rt->ch[i]=u->ch[i];
 }
 LL f[L][N*N][K];
 struct sol
 {
     char s[L];
     sol(){memset(s,,sizeof(s));}
     inline void print(){puts(s);}
     inline bool operator < (const sol &b) const
     {
         for(register int i=;i<l;++i)
             if(s[i]!=b.s[i])return s[i]<b.s[i];
     }
 }str[],stack;
 void dfs(int len,int id,int state,int now)
 {
     register int i,j,k,st;
     stack.s[len-]=now+'a';
     if(len==){str[++tot]=stack;return;}
     for(j=;j<=cnt;++j)
         if(f[len-][j][state]&&data[j]->ch[now]->id==id)
             dfs(len-,j,state,data[j]->meaning);
     if(data[id]->st)
         for(st=state&(~data[id]->st),j=;j<=cnt;++j)
             if(f[len-][j][st]&&data[j]->ch[now]->id==id)
                 dfs(len-,j,st,data[j]->meaning);
 }
 inline void get_solution()
 {
     register int i,j;tot=;
     for(j=;j<=cnt;++j)
         if(f[l][j][bin[n]-])
             dfs(l,j,bin[n]-,data[j]->meaning);
 }
 int main()
 {
     scanf("%d%d",&l,&n);root=newnode();root->fa=root;
     register int i,j,k,u,v;node *rt;LL ans=;
     bin[]=;for(i=;i<=n;++i)bin[i]=bin[i-]<<;
     for(i=;i<=n;++i)
         scanf("%s",s[i]),len[i]=strlen(s[i]),add(i);
     get_fail();
     for(i=,f[][][]=;i<=l;++i)
         for(j=;j<=cnt;++j)
             for(rt=data[j],k=;k<bin[n];++k)
                 if(f[i-][j][k])for(u=;u<;++u)
                     f[i][rt->ch[u]->id][k|rt->ch[u]->st]+=f[i-][j][k];
     for(j=;j<=cnt;++j)ans+=f[l][j][bin[n]-];
     printf("%lld\n",ans);
     if(ans<=)
     {
         get_solution();sort(str+,str+ans+);
         for(i=;i<=ans;++i)str[i].print();
     }
 }