hdu4622(后缀自动机模板)

题目链接: http://acm.hdu.edu.cn/showproblem.php?pid=4622

题意: 先输入一个长度为 n 的字符串, 然后有 q 个形如 l, r 的询问, 对于每个询问输出区间 [l, r] 中有多少不同的子串

思路: 后缀自动机模板

代码:

// 后缀自动机要理解其含义，从起点到每个点的不同路径，就是不同的子串。
// 到每一个点，不同路径，其实就是以这个点为最后一个字符的后缀，长度是介于(p->fa->len,p->len]之间的，个数也就清楚了。
// 而且这个其实是动态变化的，每加入一个字符，就可以知道新加了几个不同子串。
// 加个pos，记录位置，这样就很容易预处理了。

#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;

const int CHAR = 26;
const int MAXN = 2e3 + 10;

struct SAM_Node{
    SAM_Node *fa, *next[CHAR];
    int len, id, pos;
    SAM_Node(){};
    SAM_Node(int _len){
        fa = 0;
        len = _len;
        memset(next, 0, sizeof(next));
    }
};

SAM_Node SAM_node[MAXN << 1], *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(void){
    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(void){
    int t;
    scanf("%d", &t);
    while(t--){
        scanf("%s", str);
        memset(Q, 0, sizeof(Q));
        int n = strlen(str);
        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 + i - 1] += 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 q, l, r;
        scanf("%d", &q);
        while(q--){
            scanf("%d%d", &l, &r);
            printf("%d
", Q[l - 1][r - 1]);
        }
    }
    return 0;
}