AC自动机和KMP

AC自动机存储一个字符串的集合,把他叫做T.用i(s)表示字符串s的代表节点. 用s(i)表示节点i的代表字符串.

构建需要的时间是 $O(nc)$ 的,n为字符个数,c为字符集的大小.

AC自动机的性质.

1.从根到一个节点的路径是T中某些字串的前缀. (trie 基本性质)

2.从一个节点到叶节点的路径是这个集合中某一个(如果T的元素不可重复)字串的后缀.(trie 基本性质)

3.fail指针构成一棵fail树,树上父亲-儿子节点的关系为: 设父节点代表的字串为f,子节点为s,那么:

　　f是s的后缀,但不一定是s的前缀. (fail树基本性质)

4.如果s(i)是s(j)的后缀,那么在fail树上,i一定是j的祖先. (fail树基本性质)

 

AC自动机的一个用处就是匹配.从trie的根节点(经过fail树边/trie树边)到点i的路径条数就是能匹配到点i的字符串个数.

AC自动机的另一个用处是有了fail树以后,我们可以处理一些后缀相关的东西.此类题目大多具有自我匹配的特点,即用T中的字符串匹配T中的元素.

---

AC USACO 2015 Feb. Gold T2 Censor

一道模板题.....

#include <cstdio>
#include <fstream>
#include <iostream>
 
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
 
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>
 
typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
 
using namespace std;
 
inline int getint()
{
    int res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
 
db eps=1e-20;
inline bool feq(db a,db b)
{ return fabs(a-b)<eps; }

template<typename Type>
inline Type avg(const Type a,const Type b)
{ return a+((b-a)/2); }

//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================

int n,m;
char S[105000];
char inp[105000];

struct node
{
    node*s[26];
    node*trans[26];
    node*f;
    node*p; //parent.
    bool leaf; //is terminal ?
    char v; //witch character this node represent ?
    node()
    { memset(s,0,sizeof(s)); f=p=NULL; leaf=false; }
}pool[105000];
node*pt=pool;

node*qc[105000];
node*qf[105000];
int qh,qt;

struct Trie
{
    node*root;
    Trie(){ root=pt++; root->v='*'-'a'; }
    
    void Insert(char*f,int len)
    {
        node*x=root;
        for(int i=0;i<len;i++)
        {
            int v=f[i]-'a';
            if(x->s[v]==NULL)
            {
                x->s[v]=pt++;
                x->s[v]->p=x;
                x->s[v]->v=v;
            }
            x=x->s[v];
        }
        x->leaf=true;
    }
    
    void Construct()
    {
        node*x=root;
        qh=qt=0;
        for(int i=0;i<26;i++)
        if(x->s[i]!=NULL)
        {
            x->s[i]->f=root;
            for(int j=0;j<26;j++)
            if(x->s[i]->s[j]!=NULL)
                qc[qt]=x->s[i]->s[j],qf[qt]=root,qt++;
        }
        
        while(qh!=qt)
        {
            node*cur=qc[qh];
            node*fp=qf[qh];
            
            while(fp!=root && fp->s[cur->v]==NULL) fp=fp->f;
            if(fp->s[cur->v]!=NULL) fp=fp->s[cur->v];
            cur->f=fp;
            
            for(int i=0;i<26;i++)
                if(cur->s[i]!=NULL)
                    qc[qt]=cur->s[i],qf[qt]=fp,qt++;
            
            qh++;
        }
    }
    
    node*GetTrans(node*x,int v)
    {
        if(x->s[v]!=NULL)
            return x->trans[v]=x->s[v];
        
        if(x->trans[v]==NULL)
        {
            if(x==root) return root;
            
            return x->trans[v]=GetTrans(x->f,v);
        }
        
        return x->trans[v];
    }

    
    
    void output() { output(root); }
    void output(node*x)
    {
        printf("%c %02d %p %p %p 
",x->v+'a',x->v,x,x->f,x->p);
        for(int i=0;i<26;i++)
        if(x->s[i]!=NULL) output(x->s[i]);
    }
}T;

node*_step[105000];
node**step=_step+1;
int _prev[105000];
int*prev=_prev+1;

int main()
{
    freopen("censor.in","r",stdin);
    freopen("censor.out","w",stdout);
    
    scanf("%s",S);
    n=strlen(S);
    m=getint();
    for(int i=0;i<m;i++)
    {
        scanf("%s",inp);
        T.Insert(inp,strlen(inp));
    }
    
    T.Construct();
    
    step[-1]=T.root;
    prev[-1]=-1;
    for(int i=0;i<n;i++)
    prev[i]=i-1;
    
    for(int i=0;i<n;i++)
    {
        step[i]=T.GetTrans(step[i-1],S[i]-'a');

        if(step[i]->leaf) //we found a word.
        {
            node*p=step[i];
            int cur=i;
            while(p!=T.root && cur!=-1)
            {
                S[cur]=0;
                p=p->p;
                cur=prev[cur];
            }
            
            step[i]=step[cur];
            prev[i+1]=cur;
        }
    }
    
    for(int i=0;i<n;i++)
    if(S[i]!=0)
    printf("%c",S[i]);
    printf("
");
    
    
    return 0;
}

具体的,我们维护每个字符在自动机上的到达状态,然后匹配完毕后暴力删掉(用后向链表)匹配完毕的字符串,把当前状态变为删除字符串的前面一个字符的状态再接着匹配......

注意由于有指针跳跃操作,AC自动机的f转移就不能均摊O(n)了,于是要预处理trans表示转移到哪个节点(而不是沿着f跑).....

这里用了记忆化搜索呃.......

 

---

 

 

另一个模板.

AC BZOJ 1030

#include <cstdio>
#include <fstream>
#include <iostream>
 
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
 
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>
 
typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
 
using namespace std;
 
inline int getint()
{
    int res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
 
db eps=1e-20;
inline bool feq(db a,db b)
{ return fabs(a-b)<eps; }

template<typename Type>
inline Type avg(const Type a,const Type b)
{ return a+((b-a)/2); }

//==========================================================
//==========================================================
//==========================================================
//==========================================================

const int MOD=(10007);

inline void add(int&a,int&b)
{ a=(a+b)%MOD; }


struct node
{
    char v;
    node*s[26];
    node*trans[26];    
    node*f;
    bool danger;
    int code;
    node()
    {
        memset(s,0,sizeof(s));
        memset(trans,0,sizeof(trans));
        f=NULL;
        danger=false;
    }
}pool[6050];
node*nt=pool;

node*newnode(char v)
{ nt->v=v; nt->code=int(nt-pool); return nt++; }

struct trie
{
    node*root;
    trie(){ root=newnode('*'-'A'); }
    
    void Insert(char *f,int len)
    {
        node*cur=root;
        for(int i=0;i<len;i++)
        {
            int v=f[i]-'A';
            if(cur->s[v]==NULL)
                cur->s[v]=newnode(v);
            cur=cur->s[v];
        }
        cur->danger=true;
    }
    
    void construct() 
    {
        queue<node*> q;
        queue<node*> h;
        
        for(int i=0;i<26;i++)
        if(root->s[i])
        {
            root->s[i]->f=root;
            
            for(int j=0;j<26;j++)
            if(root->s[i]->s[j])
            q.push(root->s[i]->s[j]),h.push(root);
        }
        
        while(!q.empty())
        {
            node*x=q.front(); q.pop();
            node*p=h.front(); h.pop();
            
            //deal with current node.
            while(p!=root && !p->s[x->v]) p=p->f;
            if(p->s[x->v]) p=p->s[x->v];
            x->f=p;
            
            if(p->danger) x->danger=true;
            
            //expend sub trees.
            for(int i=0;i<26;i++)
            if(x->s[i]) q.push(x->s[i]),h.push(p);
        }
    }
    
    node* GetTrans(node*x,int v)
    {
        if(x->trans[v]) return x->trans[v];
        else return x->trans[v]=
        ( x->s[v] ? x->s[v] : ( x==root ? root : GetTrans(x->f,v) ) );
    }
};

int n,m;
char inp[200];

trie T;

int d[105][6050];

int main()
{
    n=getint();
    m=getint();
    
    for(int i=0;i<n;i++)
    {
        scanf("%s",inp);
        T.Insert(inp,strlen(inp));
    }
    
    T.construct();
    
    d[0][0]=1;
    for(int h=1;h<=m;h++)
    {
        for(node*x=pool;x<nt;x++)
        {
            if(x->danger) continue;
            for(int i=0;i<26;i++)
                add(d[h][T.GetTrans(x,i)->code],d[h-1][x->code]);
        }
    }
    
    int res=0;
    for(node*x=pool;x<nt;x++)
    if(!x->danger) add(res,d[m][x->code]);
    
    int de=1;
    for(int i=0;i<m;i++) 
    de=(de*26)%MOD;
    
    printf("%d
",((de-res)%MOD+MOD)%MOD);
    
    return 0;
}

注意 if(p->danger) x->danger=true;这一句,用于判断某字符串是否为另一个字符串的后缀.

不加这个的话,会错掉这个数据"2 2 ABA B",正确输出51.

 注意这个题的模式串很小,那个求trans的操作实际上是 $O(n^2)$ 的.

 

---

 

 

AC BZOJ 3942 USACO Feb. Silver T1 Censoring

#include <cstdio>
#include <fstream>
#include <iostream>
 
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
 
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>
 
typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
 
using namespace std;
 
inline int getint()
{
    int res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
 
db eps=1e-20;
inline bool feq(db a,db b)
{ return fabs(a-b)<eps; }

template<typename Type>
inline Type avg(const Type a,const Type b)
{ return a+((b-a)/2); }

//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================

char a[1005000];
char s[1005000];
int f[1005000];
int tran[1005000][26];
int _pre[1005000];
int*pre=_pre+1;
int _state[1005000];
int*state=_state+1;

inline int ch(char c) { return c-'a'; }
inline char revh(int k) { return (char)(k+'a'); }

char res[1005000];

int n,m;

int main()
{
    scanf("%s%s",s,a);
    n=strlen(a);
    m=strlen(s);
    
    int p=-1;
    f[0]=p;
    for(int i=1;i<n;i++)
    {
        while(p!=-1 && a[p+1]!=a[i]) p=f[p];
        if(a[p+1]==a[i]) p++;
        f[i]=p;
    }
    
    for(int i=0;i<n;i++)
    for(int j=0;j<26;j++)
    {
        char c=revh(j);
        
        /*
        int p=i;
        while(p!=-1 && a[p+1]!=c) p=f[p];
        if(a[p+1]==c) p++;
        tran[i][j]=p;
        */
        
        if(a[i+1]==c) tran[i][j]=i+1;
        else tran[i][j]=( f[i]==-1 ? ( a[0]==c ? 0 : -1 ) : tran[f[i]][j] );
    }
    
    for(int i=0;i<m;i++) pre[i]=i-1;
    state[-1]=-1;
    int curp=-1;
    for(int i=0;i<m;i++)
    {
        char c=s[i];
        
        if(curp!=-1)
        curp=tran[curp][ch(c)];
        else 
        curp=( a[0]==c )-1;
        
        state[i]=curp;
        
        if(curp==n-1)
        {
            int p=i;
            for(int j=0;j<n;j++)
            {
                s[p]=0;
                p=pre[p];
            }
            curp=state[p];
            pre[i+1]=p;
        }
    }
    
    for(int i=0;i<m;i++) if(s[i]) printf("%c",s[i]); printf("
");
    
    return 0;
}

拿了VJ上A掉的一道题去交结果TLE.......然后发现trans数组的递推的复杂度不对........

由于数据规模极高,要改trans.....WA了两发.......

递推求trans数组的时候注意对自动机的起点(编号-1)的处理.......

 

 

---

AC BZOJ 2434 NOI2011 阿狸的打字机

#include <cstdio>
#include <fstream>
#include <iostream>
 
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
 
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>
 
typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
 
using namespace std;
 
inline int getint()
{
    int res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}

//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================


int s[105000][26];
int pre[105000];
int f[105000];
int val[105000];
int ncnt=2;

int root=1;

char a[105000];
int p[105000],pcnt;

int n,m;

void BuildTrie()
{
    int x=1;
    for(int i=0;i<n;i++)
    if(islower(a[i]))
    {
        int v=a[i]-'a';
        if(!s[x][v])
        {
            s[x][v]=ncnt;
            pre[ncnt]=x;
            val[ncnt]=v;
            ncnt++;
        }
        x=s[x][v];
    }
    else if(a[i]=='P')
        p[++pcnt]=x;
    else if(a[i]=='B')
        x=pre[x];
}

typedef pair<int,int> pl;
queue<pl> q;
void BuildAutomaton()
{
    for(int i=0;i<26;i++)
    if(s[1][i])
    {
        f[s[1][i]]=1;
        for(int j=0;j<26;j++)
        if(s[s[1][i]][j])
        q.push(pl(s[s[1][i]][j],1));
    }
    
    while(!q.empty())
    {
        int x=q.front().first;
        int p=q.front().second;
        q.pop();
        int v=val[x];
        
        while(p!=1 && !s[p][v]) p=f[p];
        if(s[p][v]) p=s[p][v];
        f[x]=p;
        
        for(int i=0;i<26;i++)
        if(s[x][i]) q.push(pl(s[x][i],p));
    }
    
}

struct query_link
{
    int x;
    int t;
    int res;
    query_link*nxt;

}qpool[105000];
query_link*qds[105000];
bool cmp(const query_link&a,const query_link&b)
{ return a.t<b.t; }

struct edge
{
    int in;
    edge*nxt;
}pool[105000];
edge*et=pool;
edge*eds[105000];
void addedge(int a,int b)
{ et->in=b; et->nxt=eds[a]; eds[a]=et++; }
#define FOREACH_EDGE(i,j) for(edge*i=eds[j];i;i=i->nxt)

int loc[105000]; //points' location record.
int lci[105000]; //location's points record.
int tot[105000];
int lcnt=0;

int SeqBuildDFS(int x)
{
    lci[lcnt++]=x;
    FOREACH_EDGE(e,x)
    tot[x]+=SeqBuildDFS(e->in);
    return tot[x]+=1;
}

int t[105000];
void Change(int p,int v)
{ p++; for(;p<=lcnt;p+=(p&-p)) t[p]+=v; }
int Query(int p)
{ p++; int res=0; for(;p;p-=(p&-p)) res+=t[p]; return res; }

void DFS(int x)
{
    if(x!=1) Change(loc[x],1);
    
    for(query_link*q=qds[x];q;q=q->nxt)
    q->res=Query(loc[q->x]+tot[q->x]-1)-Query(loc[q->x]-1);
    
    for(int i=0;i<26;i++)
    if(s[x][i]) DFS(s[x][i]);
    
    if(x!=1) Change(loc[x],-1);
}


int main()
{
    scanf("%s",&a);
    n=strlen(a);
    
    BuildTrie();
    BuildAutomaton();
    
    for(int i=2;i<ncnt;i++)
    addedge(f[i],i);
    
    SeqBuildDFS(1);
    
    for(int i=0;i<lcnt;i++)
    loc[lci[i]]=i;
    
    m=getint();
    for(int i=0;i<m;i++)
    {
        int x=p[getint()];
        int y=p[getint()];
        qpool[i].x=x;
        qpool[i].t=i;
        qpool[i].nxt=qds[y];
        qds[y]=&qpool[i];
    }
    
    DFS(1);
    
    sort(qpool,qpool+m,cmp);
    for(int i=0;i<m;i++) printf("%d
",qpool[i].res);
    
    return 0;
}

 DFS写的AC自动机TLE了,不造是自己写搓还是复杂度本来就不对..........

在AC自动机的Fail树上各种乱搞.........

要求一个字符串x的对另外一个字符串y的匹配个数.

考虑暴力,就是枚举y的前缀节点,如果一个前缀节点能跳跃到x的节点就把统计量+1.

建出Fail树以后....就是神奇的乱搞.....真的好神奇.....

我们想快速求出,对于每一个询问(x,y),在fail树上,y有多少个节点在x的子树下边.

我们把Trie树DFS一遍,维护当前路径上的所有点(DFS栈中的点)的存在信息.

具体来说,就是把Fail树的DFS序搞出来,每遍历到Trie树上一个节点就把这个节点在DFS序上的代表位置的值+1,离开就-1.这样区间查询一下就能很快求出某一个子树下有多少当前正在DFS栈中的点.....

头一次写DFS序.....DFS序要注意两点,一是代表区间的长度等于子树大小;

二是子树的根一定最先遍历到,所以在它的代表区间的最左边.

 

---

AC BZOJ 3172

#include <cstdio>
#include <fstream>
#include <iostream>
 
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <cmath>
 
#include <queue>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <list>
 
typedef unsigned int uint;
typedef long long int ll;
typedef unsigned long long int ull;
typedef double db;
typedef long double ldb;
 
using namespace std;
 
inline int getint()
{
    int res=0;
    char c=getchar();
    while(c<'0' || c>'9') c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return res;
}
inline ll getll()
{
    ll res=0;
    char c=getchar();
    bool mi=false;
    while(c<'0' || c>'9') mi=(c=='-'),c=getchar();
    while('0'<=c && c<='9') res=res*10+c-'0',c=getchar();
    return mi ? -res : res;
}

//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================


int s[1005000][26];
int v[1005000];
int c[1005000];
int f[1005000];
int ncnt=1;
int Insert(char*a,int len)
{
    int x=0;
    for(int i=0;i<len;i++)
    {
        int k=a[i]-'a';
        if(!s[x][k]) s[x][k]=ncnt++;
        x=s[x][k]; c[x]=k; v[x]++;
    }
    return x;
}

int q[1005000],qh,qt;
int qr[1005000];
void Build()
{
    for(int i=0;i<26;i++)
    if(s[0][i])
    {
        f[s[0][i]]=0;
        for(int j=0;j<26;j++)
        if(s[s[0][i]][j])
        { qr[qt]=0; q[qt]=s[s[0][i]][j]; qt++; }
    }
    
    while(qh!=qt)
    {
        int x=q[qh];
        int p=qr[qh]; qh++;
        
        while(p && !s[p][c[x]]) p=f[p];
        if(s[p][c[x]]) p=s[p][c[x]];
        f[x]=p;
        
        for(int i=0;i<26;i++)
        if(s[x][i]) { q[qt]=s[x][i]; qr[qt]=p; qt++; }
    }
    
    //reversed BFS sequence is topological sorted.
    for(int i=qt-1;i>=0;i--) v[f[q[i]]]+=v[q[i]];
}

char st[100000];
void DFS(int x,int dep)
{
    if(x) st[dep]=c[x]+'a'; st[dep+1]=0;
    printf("%d %s %d %c %d
",x,st,v[x],c[x]+'a',f[x]);
    for(int i=0;i<26;i++) if(s[x][i]) DFS(s[x][i],dep+1);
}

int n;
char inp[1005000];
int loc[1005000];
int main()
{
    n=getint();
    for(int i=0;i<n;i++)
    {
        scanf("%s",inp);
        loc[i]=Insert(inp,strlen(inp));
    }
    
    Build();
    
    for(int i=0;i<n;i++) printf("%d
",v[loc[i]]);
    
    return 0;
}

我的AC自动机代码向来比人家长一倍,抄了一下别人的代码结果狂WA不止....改成原始版本后就A了.....

这个题应该也可以用后缀数据结构做....

注意拓扑序不需要用拓扑排序求出来,BFS序的逆序满足拓扑关系.

...