字符串哈希详解二维哈希 Hash

字符串hash方法

字符串 $h a s h$ 就是把一个字符串映射成一个非负整数。

（同时碰撞的概率极低）

设计一个较大质数 $p$ ，把字符串看作 $p$ 进制数。（如 $31$ ， $131$ ， $1331$ ）

（想想为什么要用质数）

对于已知的字符串 $s$ ，我们有 $h a s h$ 值为 $\text{H}(s)$ ，那么我们在 $s$ 后面增加一个字符 $c$ 构成新的字符串 $s + c$ ，该串的 $h a s h$ 值则为 $\text{H}(s)*p+(c-'a'+1)$ 。

如我们取 $p = 131$ ，对于字符串 $^{'} a b a c^{'}$ ， $p$ 进制数为 $1~2~1~3)_p$ ，即 $h a s h$ 值为 $1*p^3+2*p^2+1*p+3$ 。此时我们的字符串更新为 $^{'} a b a c d^{'}$ ，那么我们的 $^{'} a b a c^{'}$ 需要左移一位， $p$ 进制数变为 $1~2~1~3~0)_p$ ，再加上字符 $‘ d ‘$ 的值 $(^{'} d^{'} -^{'} a^{'} + 1)$ ， $p$ 进制数最后为 $1~2~1~3~4)_p$ ， $h a s h$ 值则为 $\text{H}('abac')*p+('d'-'a'+1)$

双 $h a s h$ ：使用两个质数作为 $p_1$ ， $p_2$ ，计算两个 $h a s h$ 值，当两个 $h a s h$ 值分别相等，表示两个字符串相等，这种方法碰撞概率更小

取子串hash值

所以对于一个字符串，我们需要取他的子串时，例如，对于字符串 $s$ ，我们需要取其子串 $s_{l,r}$ 的 $h a s h$ 值，我们可以用 $\text{H}(s_{0,r})-\text{H}(s_{0,l-1})*p^{r-l+1}$ 。

如 $s_{0,r}='abac'$ ， $s_{0,l-1}='ab'$ ，所以 $\text{H}(s_{0,r})=(1~2~1~3)_p$ ， $\text{H}(s_{0,l-1})=(1~2)_p$ ，所以对于 $s_{l,r}='ac'$ ，先将 $\text{H}(s_{0,l-1})=(1~2)_p$ 向左移 $length(s_{l,r})$ 位，变成 $\text{H}(s_{0,l-1})*p^2=(1~2~0~0)_p$ ，最后 $\text{H}(s_{0,r})-\text{H}(s_{0,l-1})*p^2=(1~3)_p=\text{H}('ac')=\text{H}(s_{l,r})$

溢出与取模

当 $p$ 很大且字符串很长时，字符串的 $h a s h$ 值也会很大，这时候一般需要设计一个值 $m$ 对字符串的 $h a s h$ 值进行取模，有 $2$ 种处理方法：

使用 $2^{64}$ 进行取模，即直接使用 $u n s i g n e d l o n g l o n g$ 储存 $h a s h$ 值，产生溢出时相当于自动对 $2^{64}$ 进行取模
使用一个大质数进行取模

总体来说，字符串 $h a s h$ 很难构造能卡的数据，相对来说第一个和双 $h a s h$ 碰撞概率更小一些，且由于不需要取模，第一个方法常数会小一点。

code

// acwing 兔子与兔子
#include <bits/stdc++.h>
// using namespace std;

#define ull unsigned long long
#define p 131

int n;
char s[1000005];
ull b[1000005];
ull hash[1000005];

int main() {
    
    
    b[0] = 1; // p的0次方
    hash[0] = 0;
    scanf("%s", s);
    int len = strlen(s);
    for (int i = 1; i <= len + 3; i++) {
    
    
        b[i] = b[i - 1] * p;
        hash[i] = hash[i - 1] * p + (s[i - 1] - 'a' + 1);
    }
    scanf("%d", &n);
    for (int i = 0, l1, l2, r1, r2; i < n; i++) {
    
    
        scanf("%d%d%d%d", &l1, &r1, &l2, &r2);
        ull s1 = hash[r1] - hash[l1 - 1] * b[r1 - l1 + 1];
        ull s2 = hash[r2] - hash[l2 - 1] * b[r2 - l2 + 1];
        if (s1 == s2) {
    
    
            puts("YES");
        } else
            puts("NO");
    }
    return 0;
}

二维哈希

可以类比二维前缀和，注意横向 $h a s h$ 和纵向 $h a s h$ 所用的 $p$ 值不要相同。

code

// UVa 11019
#include <bits/stdc++.h>
using namespace std;

#define ull unsigned long long
#define p1 131
#define p2 1331

int n, m, x, y;
char s1[1005][1005], s2[105][105];
ull h[1005][1005], h2[105][105], b1[1005], b2[1005];

void solve() {
    
    
    int ans = 0;
    scanf("%d%d", &n, &m);
    getchar();
    for (int i = 1; i <= n; i++) scanf("%s", s1[i]);
    scanf("%d%d", &x, &y);
    getchar();
    for (int i = 1; i <= x; i++) scanf("%s", s2[i]);
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
            h[i][j] = h[i][j - 1] * p1 + (int)(s1[i][j - 1] - 'a' + 1);
    for (int j = 1; j <= m; j++)
        for (int i = 1; i <= n; i++) h[i][j] += h[i - 1][j] * p2;
    for (int i = 1; i <= x; i++)
        for (int j = 1; j <= y; j++)
            h2[i][j] = h2[i][j - 1] * p1 + (int)(s2[i][j - 1] - 'a' + 1);
    for (int j = 1; j <= y; j++)
        for (int i = 1; i <= x; i++) h2[i][j] += h2[i - 1][j] * p2;
    ull val = h2[x][y];
    // printf("# %llu #\n", val);
    for (int i = x; i <= n; i++) {
    
    
        for (int j = y; j <= m; j++) {
    
    
            ull tmp = h[i][j] - h[i - x][j] * b2[x] - h[i][j - y] * b1[y] +
                      h[i - x][j - y] * b1[y] * b2[x];
            if (tmp == val) ++ans;
        }
    }
    printf("%d\n", ans);
}

int main() {
    
    
    b1[0] = b2[0] = 1;
    for (int i = 1; i < 1000 + 3; i++) {
    
    
        b1[i] = b1[i - 1] * p1;
        b2[i] = b2[i - 1] * p2;
    }
    int t;
    scanf("%d", &t);
    while (t--) solve();
    return 0;
}

参考《算法竞赛进阶指南》

字符串hash

hdu 1711

poj 1200

poj 3461

二维hash

UVa 11019