HDU 4622 Reincarnation （查询一段字符串的不同子串个数，后缀自动机）

这题就是查询一个区间内的不同子串的个数。

如果单单是求一个字符串的不同子串个数，无论是后缀数组还是后缀自动机都非常容易实现。

N<=2000.

我是用后缀自动机预处理出所有区间的不同子串个数。

建立n次后缀自动机。

后缀自动机要理解其含义，从起点到每个点的不同路径，就是不同的子串。

到每一个点，不同路径，其实就是以这个点为最后一个字符的后缀，长度是介于(p->fa->len,p->len]之间的，个数也就清楚了。

而且这个其实是动态变化的，每加入一个字符，就可以知道新加了几个不同子串。

加个pos，记录位置，这样就很容易预处理了。

#include 
#include 
#include 
#include 
using namespace std;

const int CHAR = 26;
const int MAXN = 2020;
struct SAM_Node
{
    SAM_Node *fa,*next[CHAR];
    int len;
    int id,pos;
    SAM_Node(){}
    SAM_Node(int _len)
    {
        fa = 0;
        len = _len;
        memset(next,0,sizeof(next));
    }
};
SAM_Node SAM_node[MAXN*2], *SAM_root, *SAM_last;
int SAM_size;
SAM_Node *newSAM_Node(int len)
{
    SAM_node[SAM_size] = SAM_Node(len);
    SAM_node[SAM_size].id = SAM_size;
    return &SAM_node[SAM_size++];
}
SAM_Node *newSAM_Node(SAM_Node *p)
{
    SAM_node[SAM_size] = *p;
    SAM_node[SAM_size].id = SAM_size;
    return &SAM_node[SAM_size++];
}
void SAM_init()
{
    SAM_size = 0;
    SAM_root = SAM_last = newSAM_Node(0);
    SAM_node[0].pos = 0;
}
void SAM_add(int x,int len)
{
    SAM_Node *p = SAM_last, *np = newSAM_Node(p->len+1);
    np->pos = len;
    SAM_last = np;
    for(;p && !p->next[x];p = p->fa)
        p->next[x] = np;
    if(!p)
    {
        np->fa = SAM_root;
        return;
    }
    SAM_Node *q = p->next[x];
    if(q->len == p->len + 1)
    {
        np->fa = q;
        return;
    }
    SAM_Node *nq = newSAM_Node(q);
    nq->len = p->len + 1;
    q->fa = nq;
    np->fa = nq;
    for(;p && p->next[x] == q;p = p->fa)
        p->next[x] = nq;
}
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 Q[MAXN][MAXN];
char str[MAXN];
int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%s",str);
        int n = strlen(str);
        memset(Q,0,sizeof(Q));
        for(int i = 0;i < n;i++)
        {
            SAM_init();
            for(int j = i;j < n;j++)
            {
                SAM_add(str[j]-'a',j-i+1);
            }
            for(int j = 1;j < SAM_size;j++)
            {
                Q[i][SAM_node[j].pos-1+i]+=SAM_node[j].len - SAM_node[j].fa->len;
            }
            for(int j = i+1;j < n;j++)
                Q[i][j] += Q[i][j-1];
        }
        int M;
        int u,v;
        scanf("%d",&M);
        while(M--)
        {
            scanf("%d%d",&u,&v);
            u--;v--;
            printf("%d\n",Q[u][v]);
        }
    }
    return 0;
}