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.

 

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.

 

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

 

 

 

#include <bits/stdc++.h>

inline long long read(){long long x=,f=;char ch=getchar();while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}return x*f;}

using namespace std;

const int N = 2e3+;

const long long mod = ;

long long now;

int isPlus[N * ],endpos[N * ];int d[N * ];

int tot,slink[*N],trans[*N][],minlen[*N],maxlen[*N],pre;

int newstate(int _maxlen,int _minlen,int* _trans,int _slink){

    maxlen[++tot]=_maxlen;minlen[tot]=_minlen;

    slink[tot]=_slink;

    if(_trans)for(int i=;i<;i++)trans[tot][i]=_trans[i],d[_trans[i]]+=;

    return tot;

}

long long update(int u) {

    return 1LL*(maxlen[u] - minlen[u] + );

}

int add_char(char ch,int u){

    int c=ch-'a',v=u;

    int z=newstate(maxlen[u]+,-,NULL,);

    isPlus[z] = ;

    while(v&&!trans[v][c]){trans[v][c]=z;d[z]+=;v=slink[v];}

    if(!v){ minlen[z]=;slink[z]=;now += update(z);return z;}

    int x=trans[v][c];

    if(maxlen[v]+==maxlen[x]){slink[z]=x;minlen[z]=maxlen[x]+;now += update(z);return z;}

    int y=newstate(maxlen[v]+,-,trans[x],slink[x]);

    now -= update(x);

    slink[z]=slink[x]=y;minlen[x]=minlen[z]=maxlen[y]+;

    now += update(x);

    while(v&&trans[v][c]==x){trans[v][c]=y;d[x]--,d[y]++;v=slink[v];}

    minlen[y]=maxlen[slink[y]]+;

    now += update(y);now += update(z);

    return z;

}

void init_sam() {

    for(int i = ; i <= tot; ++i)

        for(int j = ; j < ; ++j) trans[i][j] = ;

    pre = tot = ;

}

int T,n;

long long ans[];

char a[N * ];

struct ss{int L,R,id;}Q[];

int cmp(ss s1,ss s2) {

    if(s1.L == s2.L)return s1.R < s2.R;

    return s1.L < s2.L;

}

int main() {

    scanf("%d",&T);

    while(T--) {

        scanf("%s%d",a+,&n);

        for(int i = ; i <= n; ++i)

            scanf("%d%d",&Q[i].L,&Q[i].R),Q[i].id = i;

        sort(Q+,Q+n+,cmp);

        int l = ,r = ;

        for(int i = ; i <= n; ++i) {

            if(Q[i].L != Q[i-].L) {init_sam();

                l = Q[i].L,r = l-;

                now = ;

            }

            while(r < Q[i].R){

                pre = add_char(a[(++r)],pre);

            }

            ans[Q[i].id] = now;

        }

        for(int i = ; i <= n; ++i) printf("%lld\n",ans[i]);

    }

    return ;

}

#include <cstdio>

#include <cstdlib>

#include <cstring>

typedef unsigned long long int ULL;

//BKDRHash，最優的字符串hash算法。hash一開始是等于0的

const int seed = ; // 31 131 1313 13131 131313 etc..

const int maxn = +;

char str[maxn];

ULL powseed[maxn]; // seed的i次方 爆了也沒所謂，sumHash的也爆。用了ULL，爆了也沒所謂，也能唯一確定它，無符號

ULL sumHash[maxn]; //前綴hash值

int ans[maxn][maxn]; //ans[L][R]就代表ans,就是區間[L,R]內不同子串的個數

const int MOD = ;

struct StringHash

{

    int first[MOD+],num;

    ULL EdgeNum[maxn]; // 表明第i條邊放的數字(就是sumHash那個數字)

    int next[maxn],close[maxn]; //close[i]表示與第i條邊所放權值相同的開始的最大位置

    //就比如baba，現在枚舉長度是2，開始的時候ba，close[1] = 1;表明"ba"開始最大位置是從1開始

    //然后枚舉到下一個ba的時候，close[1]就要變成3了，開始位置從3開始了

    void init ()

    {

        num = ; memset (first,,sizeof first);

        return ;

    }

    int insert (ULL val,int id) //id是用來改變close[]的

    {

        int u = val % MOD;

        for (int i = first[u]; i ; i = next[i]) //存在邊不代表出現過，出現過要用val判斷，val才是唯一的，邊還是壓縮后(%MOD)的呢

        {

            if (val == EdgeNum[i]) //出現過了

            {

                int t = close[i]; close[i] = id;//更新最大位置

                return t;

            }

        }

        ++num; //沒出現過的話，就加入圖吧

        EdgeNum[num] = val; // 這個才是精確的

        close[num] = id;

        next[num] = first[u];

        first[u] = num;

        return ;//沒出現過

    }

}H;

void work ()

{

    scanf ("%s",str+);

    int lenstr = strlen(str+);

    for (int i=;i<=lenstr;++i)

        sumHash[i] = sumHash[i-]*seed + str[i];

    memset(ans,,sizeof(ans));

    for (int L=;L<=lenstr;++L) //暴力枚舉子串長度

    {

        H.init();

        for (int i=;i+L-<=lenstr;++i)

        {

            int pos = H.insert(sumHash[i+L-]-powseed[L]*sumHash[i-],i);

            ans[i][i+L-] ++;//ans[L][R]++，自己是一個

            ans[pos][i+L-]--;//pos放回0是沒用的

        }

    }

    for (int i = lenstr; i>=; i--)

    {

        for (int j=i;j<=lenstr;j++)

        {

            ans[i][j] += ans[i+][j]+ans[i][j-]-ans[i+][j-];

        }

    }

    int m;

    scanf ("%d",&m);

    while (m--)

    {

        int L,R;

        scanf ("%d%d",&L,&R);

        printf ("%d\n",ans[L][R]);

    }

    return ;

}

int main ()

{

    powseed[] = ;

    for (int i = ; i <= maxn-; ++i) powseed[i] = powseed[i-] * seed;

    int t;

    scanf ("%d",&t);

    while (t--) work();

    return ;

}