HDU4622 Reincarnation 字符串哈希

Reincarnation

Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 131072/65536 K (Java/Others)
Total Submission(s): 4571    Accepted Submission(s): 1868

Problem Description

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.

 

 直接用的kuangbin的板子

#include <bits/stdc++.h>
using namespace std;
const int HASH = 10007;
const int MAXN = 2010;
struct HASHMAP
{
        int head[HASH],next[MAXN],size;
        unsigned long long state[MAXN];
        int f[MAXN];
        void init()
        {
                size = 0;
                memset(head,-1,sizeof(head));
        }
        int insert(unsigned long long val,int _id)
        {
                int h = val%HASH;
                for (int i = head[h]; i != -1; i = next[i])
                {
                        if (val == state[i])
                        {
                                int tmp = f[i];
                                f[i] = _id;
                                return tmp;
                        }
                }
                f[size] = _id;
                state[size] = val;
                next[size] = head[h];
                head[h] = size++;
                return 0;
        }
} H;
const int SEED = 13331;
unsigned long long P[MAXN];
unsigned long long S[MAXN];
char str[MAXN];
int ans[MAXN][MAXN];
int main()
{
        P[0] = 1;
        for(int i = 1; i < MAXN; i++)
                P[i] = P[i - 1] * SEED;
        int T;
        scanf("%d",&T);
        while(T -- )
        {
                scanf("%s",str);
                int n = strlen(str);
                S[0] = 0;
                for(int i = 1; i <= n; i++)
                        S[i] = S[i - 1]*SEED + str[i - 1];
                memset(ans,0,sizeof(ans));
                for(int L = 1; L <= n; L++)
                {
                        H.init();
                        for(int i = 1; i + L - 1 <= n; i++)
                        {
                                int l = H.insert(S[i+L - 1] - S[i - 1]*P[L],i);
                                ans[i][i+L - 1] ++;
                                ans[l][i+L - 1] -- ;
                        }
                }
                for(int i = n; i >= 0; i -- )
                        for(int j = i; j <= n; j++)
                                ans[i][j] += ans[i+1][j] + ans[i][j - 1] - ans[i+1][j
                                                - 1];
                int m,u,v;
                scanf("%d",&m);
                while(m -- )
                {
                        scanf("%d%d",&u,&v);
                        printf("%d
",ans[u][v]);
                }
        }
        return 0;
}