后缀自动机（最长公共子串、模板）spoj1811

今天又把后缀自动机看了一遍，终于看明白了.

先说一下后缀自动机的几条性质：

1.从初始状态出发，所有到达终止状态的串是后缀

2.从起点出发到达每个节点的路径是串的所有子串

3.从一个接受态沿Parent走到达的还是接受态

4.一个节点及其父辈代表的船有相同的后缀，且长度递减

还有就是后缀自动机的构造过程，下面给大家推荐几个博客：

后缀自动机(FHQ+Neroysq补完)

后缀自动机学习

后缀自动机与线性构造后缀树

下面给个例题和模板：spoj1811求两个串的最长公共子串，有后缀数组后超时

后缀自动机：首先以其中一个穿构造后缀自动机，然后沿par指针匹配

pos表示在原串中的位置，len表示到达至各节点的最长的长度

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<vector>
#include<cmath>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
const int maxn=250010;
const int SIGMA_SIZE=26;
char str1[maxn],str2[maxn];
struct SAM_Node
{
    SAM_Node *par,*next[SIGMA_SIZE];
    int len,id,pos;
    SAM_Node(){}
    SAM_Node(int _len)
    {
        par=0;
        len=_len;
        memset(next,0,sizeof(next));
    }
};
SAM_Node node[maxn*2],*root,*last;
int SAM_size;
SAM_Node *newSAM_Node(int len)
{
    node[SAM_size]=SAM_Node(len);
    node[SAM_size].id=SAM_size;
    return &node[SAM_size++];
}
SAM_Node *newSAM_Node(SAM_Node *p)
{
    node[SAM_size]=*p;
    node[SAM_size].id=SAM_size;
    return &node[SAM_size++];
}
void SAM_init()
{
    SAM_size=0;
    root=last=newSAM_Node(0);
    node[0].pos=0;
}
void SAM_add(int x,int len)
{
    SAM_Node *p=last,*np=newSAM_Node(p->len+1);
    np->pos=len;
    last=np;
    while(p&&!p->next[x])
    {
        p->next[x]=np;
        p=p->par;
    }
    if(!p)
    {
        np->par=root;
        return ;
    }
    SAM_Node *q=p->next[x];
    if(q->len==p->len+1)
    {
        np->par=q;
        return ;
    }
    SAM_Node *nq=newSAM_Node(q);
    nq->len=p->len+1;
    q->par=nq;
    np->par=nq;
    while(p&&p->next[x]==q)
    {
        p->next[x]=nq;
        p=p->par;
    }
}
void SAM_build(char *s)
{
    SAM_init();
    int len=strlen(s);
    for(int i=0;i<len;i++)
        SAM_add(s[i]-'a',i+1);
}
int main()
{
    while(scanf("%s%s",str1,str2)!=EOF)
    {
        SAM_build(str1);
        SAM_Node *tmp=root;
        int len=strlen(str2);
        int cnt=0,ans=0;
        for(int i=0;i<len;i++)
        {
            int c=str2[i]-'a';
            if(tmp->next[c])
                tmp=tmp->next[c],cnt++;
            else
            {
                while(tmp&&!tmp->next[c])
                    tmp=tmp->par;
                if(!tmp)
                    tmp=root,cnt=0;
                else
                {
                    cnt=tmp->len+1;
                    tmp=tmp->next[c];
                }
            }
            ans=max(ans,cnt);
        }
        printf("%d\n",ans);
    }
    return 0;
}