后缀自动机poj1509

今天终于知道什么是后缀自动机了，知道他长啥样了，知道他的几个性质了，但是构造的过程还没太明白，对于用节点维护某些东西肯定还不行，先敲一道水题，算整理一下模板

poj1509有最小表示法的算法，这里中后缀自动机求解。

思路：把串重复一边加到后面，然后构造后缀自动机，然后从根遍历字符串长度，得到位置

#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=10010;
const int SIGMA_SIZE=26;
struct SAM_Node
{
    SAM_Node *par,*next[SIGMA_SIZE];
    int len;//从开始到当前位置的长度
    int id;//状态节点编号
    int pos;
    SAM_Node(){}
    SAM_Node(int ilen)
    {
        par=0;
        len=ilen;
        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 N;
char s[maxn*2];
int main()
{
    scanf("%d",&N);
    while(N--)
    {
        scanf("%s",s);
        int len=strlen(s);
        for(int i=0;i<len;i++)
            s[len+i]=s[i];
        s[2*len]='\0';
        SAM_build(s);
        SAM_Node *p=root;
        for(int i=0;i<len;i++)
        {
            for(int j=0;j<SIGMA_SIZE;j++)
                if(p->next[j])
                {
                    p=p->next[j];
                    break;
                }
        }
        printf("%d\n",p->len-len+1);
    }
    return 0;
}