HDU 4622 Reincarnation

Reincarnation

Time Limit: 3000ms

Memory Limit: 65536KB

This problem will be judged on HDU. Original ID: 4622
64-bit integer IO format: %I64d      Java class name: Main

 

Now you are back,and have a task to do:
Given you a string s consist of lower-case English letters only,denote f(s) as the number of distinct sub-string of s.
And you have some query,each time you should calculate f(s[l...r]), s[l...r] means the sub-string of s start from l end at r.

 

Input

The first line contains integer T(1<=T<=5), denote the number of the test cases.
For each test cases,the first line contains a string s(1 <= length of s <= 2000).
Denote the length of s by n.
The second line contains an integer Q(1 <= Q <= 10000),denote the number of queries.
Then Q lines follows,each lines contains two integer l, r(1 <= l <= r <= n), denote a query.

 

Output

For each test cases,for each query,print the answer in one line.

 

Sample Input

2
bbaba
5
3 4
2 2
2 5
2 4
1 4
baaba
5
3 3
3 4
1 4
3 5
5 5

Sample Output

3
1
7
5
8
1
3
8
5
1

Hint

I won't do anything against hash because I am nice.Of course this problem has a solution that don't rely on hash.

 

Source

2013 Multi-University Training Contest 3

 

解题：据说是CLJ的题

 

后缀自动机求某个区间子串的个数

 

#include <bits/stdc++.h>
using namespace std;
const int maxn = 5010;
int ret;
struct node {
    int f,len,son[26];
    void init() {
        memset(son,-1,sizeof son);
        len = 0;
        f = -1;
    }
};
struct SAM {
    node e[maxn<<1];
    int tot,last;
    int newnode(int len = 0) {
        e[tot].init();
        e[tot].len = len;
        return tot++;
    }
    void init() {
        tot = last = 0;
        newnode();
    }
    void extend(int c) {
        int p = last,np = newnode(e[p].len + 1);
        while(p != -1 && e[p].son[c] == -1) {
            e[p].son[c] = np;
            p = e[p].f;
        }
        if(p == -1) {
            e[np].f = 0;
            ret += e[np].len - e[0].len;
        } else {
            int q = e[p].son[c];
            if(e[p].len + 1 == e[q].len) {
                e[np].f = q;
                ret += e[np].len - e[q].len;
            } else {
                int nq = newnode();
                e[nq] = e[q];
                e[q].f = e[np].f = nq;
                e[nq].len = e[p].len + 1;
                ret += e[np].len - e[e[np].f].len;
                while(p != -1 && e[p].son[c] == q) {
                    e[p].son[c] = nq;
                    p = e[p].f;
                }
            }
        }
        last = np;
    }
} sam;
int ans[2010][2010];
char str[maxn];
int main() {
    int kase,q,L,R;
    scanf("%d",&kase);
    while(kase--) {
        scanf("%s",str);
        for(int i = 0; str[i]; ++i) {
            sam.init();
            ret = 0;
            for(int j = i; str[j]; ++j) {
                sam.extend(str[j] - 'a');
                ans[i][j] = ret;
            }
        }
        scanf("%d",&q);
        while(q--) {
            scanf("%d%d",&L,&R);
            printf("%d
",ans[L-1][R-1]);
        }
    }
    return 0;
}