字符串Hash入门+例题详解

最近打暑假多校，发现有许多字符串算法自己有所遗忘，今天就借着补题在这开一个坑，把那几个基础的字符串算法总结复习一下，顺便写几个模板，供今后使用。这篇博客主要就是总结一下字符串Hash，并提一下例题。

代码实现如下

    H[0]=0;
    for(int i=1;i<=4;i++)
    H[i]=H[i-1]*b+(C[i]-'A'+1);

通常，题目要求的是判断主串的一段字符与另一个匹配串是否匹配，即判断字符串 C=c₁c₂…c_m 从位置 k+1 开始的长度为 n 的子串 C’=c_k+1c_k+2…c_k+n 的哈希值与另一匹配串 S=s₁s₂…s_n 的哈希值是否相等，则：
H(C’) = H(C,k+n) - H(C,k)*bⁿ
于是我们只要预处理求得 b^n ,就能在 O(1)时间内得到任意字符串的子串哈希值，从而完成字符串匹配，那么上述字符串匹配问题的算法时间复杂度就为 O(n+m)。

代码实现如下

  for(int i=0;i<=m-n;++i)
    {
        ull hash=hashC[i+n]-hashC[i]*pow[n];
        if(hash==hashS)
        ans++;
    }

如字符串 C=“ACDA”,S=“CD”,当 k=1, n=2 时：
H(C’) = H(C,1+2) - H(C,1)*b²
= (1*b²+3*b+4) - (1*b²)
= 3*b + 4
H(S) = 3*b + 4
因此子串 C’ 与匹配串 S 匹配。
在实现算法时，可以利用 32 位或 64 位无符号整数计算哈希值，此时 h=2³² 或 h=2⁶⁴，通过自然溢出省去求模运算。(因为无符号整数，大于最大值后会以最大值+1为模数取模)
注1：众所周知，hash算法有时会产生冲突，但是在一般比赛中用字符串Hash产生冲突的概率是很小的，如果发现错了，可以换个基数或模数，或者采用“双哈希”来避免冲突。
注2：我们在预处理 b^n 时，要根据题目来选择预处理方式（虽然一般不会卡这个），如果只有一组输入，匹配串长度固定，那么利用快速幂求即可。如果有多组输入，每组匹配串长度皆不同，递推更好一些。
递推代码

    pow[0]=1;
    for(int i=1;i<=10002;i++)//预处理base^n
    pow[i]=pow[i-1]*base;

/**
快速幂预处理，取模
跑了 813MS
*/
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn=1e6+5;
const int maxm=1e4+5;
const int base=29;
const long long mod=1e7+5;
int n;
char W[maxm],T[maxn];
long long quickpow(long long a,int b)//快速幂
{
    long long sum=1;
    while(b>0)
    {
        if(b&1)
        sum=(sum*a)%mod;
        b>>=1;
        a=(a*a)%mod;
    }
    return sum;
}
int main()
{
    scanf("%d",&n);
    while(n--)
    {
        scanf("%s",W);
        scanf("%s",T);
        int lenw=strlen(W);
        int lent=strlen(T);
        long long hashw=0;//初始hash
        long long hasht=0;
        int ans=0;//统计个数
        for(int i=0;i<lenw;++i)
        {
            hashw=(hashw*base+1ll*(W[i]-'A'+1))%mod;
            hasht=(hasht*base+1ll*(T[i]-'A'+1))%mod;
        }
        if(hashw==hasht)
        ans++;
        long long cnt=quickpow((long long)base,lenw-1);//预处理b^n
        for(int i=lenw;i<lent;++i)//T向后找子串去和W比较
        {
            hasht=(hasht-1ll*cnt*(T[i-lenw]-'A'+1))%mod;
            hasht=(hasht+mod)%mod;//防止为负数
            hasht=(hasht*base+1ll*(T[i]-'A'+1))%mod;
            if(hashw==hasht)
            ans++;
        }
        printf("%d\n",ans);
    }
    return 0;
}

/**
递推预处理，未取模
跑了 235MS
*/
#include <iostream>
#include <stdio.h>
#include <string.h>
#include <cstring>
#include <algorithm>
typedef unsigned long long ull;
using namespace std;
const int maxn=1e6+5;
const int maxm=1e4+5;
const int base=29;
ull pow[maxm];
char W[maxm],T[maxn];
ull hasht[maxn];
int n;
ull hashs;
int ans;
void init()
{
    ans=0;
    hashs=0;
}
int main()
{
    pow[0]=1;
    for(int i=1;i<=10002;i++)//预处理base^n
    pow[i]=pow[i-1]*base;
    scanf("%d",&n);
    while(n--)
    {
        init();//初始化
        scanf("%s",&W);
        scanf("%s",&T);
        int lens=strlen(W);
        int lent=strlen(T);
        for(int i=1;i<=lens;++i)
        hashs=hashs*base+(ull)(W[i-1]-'A'+1);
        hasht[0]=(ull)(T[0]-'A'+1);
        for(int i=1;i<=lent;++i)
        hasht[i]=hasht[i-1]*base+(ull)(T[i-1]-'A'+1);
        for(int i=0;i<=lent-lens;++i)
        {
            ull hash=hasht[i+lens]-hasht[i]*pow[lens];
            if(hash==hashs)
            ans++;
        }
        printf("%d\n",ans);
    }
    return 0;
}