hdu 4622 Reincarnation (后缀自动机)

题意：

给出一个串，q个询问，每个询问要求这个区间[l,r]不同子串的数目。

题解：

这题有两种做法，一种是后缀数组，一种是自动机，两种方法的思想是一致。

用自动机做之前要知道一个性质：每次加入某个字符，会到len[last]-len[fa[last]]个未出现过的子串，并且都是以last为结尾的。那么就好办了，我们并不好在在线获得答案，我们先将询问存下来，然后通过排序按照区间左端点为第一key，右端点为第二key。这样可以大大的降低复杂度。判断i区间的l是否等于i-1区间的l，如果相等从上次的last继续插入字符统计个数，如果不相等就从新建立自动机。这个算法是线性的。

#include<iostream>
#include<math.h>
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<vector>
#include<queue>
#include<map>
#include<set>
using namespace std;
#define B(x) (1<<(x))
typedef long long ll;
const int oo=0x3f3f3f3f;
const ll OO=1LL<<61;
const int MOD=10007;
const int maxn=2020;
const int maxm=10010;
const int SIZE=maxn<<1;
const int type=26;
char str[maxn],path[SIZE];
int pos[maxm];

struct QQ{
    int l,r;
    int ans;
}q[maxm];

bool cmp(int a,int b){
    if(q[a].l==q[b].l)
        return q[a].r<q[b].r;
    return q[a].l<q[b].l;
}

struct SuffixAutoMaton{

    int next[SIZE][type],fa[SIZE],len[SIZE];
    int tol,last;
    int newNode(int x){

        len[tol]=x;
        fa[tol]=-1;
        for(int i=0;i<type;i++)
            next[tol][i]=-1;
        return tol++;
    }

    void Init(){

        tol=0;
        last=newNode(0);
    }

    int add(int k){

        int now=last;
        int end=newNode(len[now]+1);
        while(now!=-1&&next[now][k]==-1){

            next[now][k]=end;
            now=fa[now];
        }
        if(now==-1) fa[end]=0;
        else{

            int nxt=next[now][k];
            if(len[nxt]==len[now]+1) fa[end]=nxt;
            else{

                int cnxt=newNode(len[now]+1);
                for(int i=0;i<type;i++)next[cnxt][i]=next[nxt][i];
                fa[cnxt]=fa[nxt];
                fa[nxt]=fa[end]=cnxt;
                while(now!=-1&&next[now][k]==nxt){
                    next[now][k]=cnxt;
                    now=fa[now];
                }
            }
        }
        last=end;
        return len[last]-len[fa[last]];
    }

    int Insert(char T[],int s,int e){

        int ans=0;
        for(int i=s;i<=e;i++){
            ans+=add(T[i]-'a');
        }
        return ans;
    }
}sam;

int main(){

    int T,Q,pre;
    scanf("%d",&T);
    while(T--){

        scanf("%s",str);
        scanf("%d",&Q);
        for(int i=1;i<=Q;i++){
            scanf("%d %d",&q[i].l,&q[i].r);
            q[i].l--;
            q[i].r--;
            pos[i]=i;
        }
        sort(pos+1,pos+1+Q,cmp);
        sam.Init();
        q[pos[1]].ans=pre=sam.Insert(str,q[pos[1]].l,q[pos[1]].r);
        for(int i=2;i<=Q;i++){
            if(q[pos[i]].l==q[pos[i-1]].l&&q[pos[i]].r>=q[pos[i-1]].r){
                q[pos[i]].ans=sam.Insert(str,q[pos[i-1]].r+1,q[pos[i]].r)+pre;
                pre=q[pos[i]].ans;
            }else{
                sam.Init();
                q[pos[i]].ans=pre=sam.Insert(str,q[pos[i]].l,q[pos[i]].r);
            }
        }
        for(int i=1;i<=Q;i++)printf("%d\n",q[i].ans);
    }
    return 0;
}