hdu 5685(逆元)

Problem A

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 520    Accepted Submission(s): 203

Problem Description

度熊手上有一本字典存储了大量的单词，有一次，他把所有单词组成了一个很长很长的字符串。现在麻烦来了，他忘记了原来的字符串都是什么，神奇的是他竟然记得原来那些字符串的哈希值。一个字符串的哈希值，由以下公式计算得到：

H(s)=∏i≤len(s)i=1(Si−28) (mod 9973)

Si代表 S[i] 字符的 ASCII 码。

请帮助度熊计算大字符串中任意一段的哈希值是多少。

 

 

Input

多组测试数据，每组测试数据第一行是一个正整数N，代表询问的次数，第二行一个字符串，代表题目中的大字符串，接下来N行，每行包含两个正整数a和b，代表询问的起始位置以及终止位置。

1≤N≤1,000

1≤len(string)≤100,000

1≤a,b≤len(string)

 

 

Output

对于每一个询问，输出一个整数值，代表大字符串从 a 位到 b 位的子串的哈希值。

 

 

Sample Input

2 ACMlove2015 1 11 8 10 1 testMessage 1 1

 

 

Sample Output

6891 9240 88

 

没接触过数论方面的算法。。搞了好久才弄清楚逆元。(以下为个人理解)

 

逆元：若 (a/b)%p = r 除法的话我们不好取模,所以我们就要b^-1 这里的b^-1指的是b的逆元，(b*b^-1)%p = 1 ===> b*b^-1 = k*p+1 ===》 -kp+b*b^-1 = 1 这里的方程中的未知数 b^-1 我们可以用扩展欧几里德(前提是p,b互素,因为gcd(p,b)要为1)来求解。下面给出代码以及逆元模板。

#include <stdio.h>
#include <math.h>
#include <iostream>
#include <algorithm>
#include <string.h>
#include <stdlib.h>
using namespace std;
typedef long long LL;
const int N = 100005;
char str[N];
LL inv[10005]; ///逆元
LL num[N];
LL extend_gcd(LL a,LL b,LL &x,LL &y){
    if( b == 0 ) {
        x = 1;
        y = 0;
        return a;
    }
    else{
        LL x1,y1;
        LL d = extend_gcd (b,a % b,x1,y1);
        x = y1;
        y= x1 - a / b * y1;
        return d;
    }
}
LL mod_reverse(LL a,LL n)
{
    LL x,y;
    LL d=extend_gcd(a,n,x,y);
    if(d==1) return (x%n+n)%n;
    else return -1;
}
void init(){
    inv[0] = 0,inv[1]=1;
    for(int i=2;i<=10000;i++){
        inv[i] = mod_reverse(i,9973);
    }
}
int main()
{
    int m;
    init();
    while(~scanf("%d",&m)){
        scanf("%s",str+1);
        int len = strlen(str+1);
        num[1] = str[1]-28;
        for(int i=2;i<=len;i++){
            int x = str[i]-28;
            num[i] = (num[i-1]*x)%9973;
        }
        while(m--){
            int l,r;
            scanf("%d%d",&l,&r);
            if(l==1) printf("%d\n",num[r]);
            else printf("%lld\n",num[r]*inv[num[l-1]]%9973); ///(num[r]/num[l-1])%9973
        }
    }
}