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

字符串hash方法

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

（同时碰撞的概率极低）

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

（想想为什么要用质数）

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

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

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

取子串hash值

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

如 $s_{0,r}{=}^{\prime }aba{c}^{\prime }$，$s_{0,l-1}{=}^{\prime }a{b}^{\prime }$，所以 $\text{H}(s_{0,r})=(1213{)}_p$，$\text{H}(s_{0,l-1})=(12{)}_p$，所以对于 $s_{l,r}{=}^{\prime }a{c}^{\prime }$，先将 $\text{H}(s_{0,l-1})=(12{)}_p$ 向左移 $length(s_{l,r})$ 位，变成$\text{H}(s_{0,l-1})\ast p^2=(1200{)}_p$，最后$\text{H}(s_{0,r})-\text{H}(s_{0,l-1})\ast p^2=(13{)}_p=\text{H}{(}^{\prime }a{c}^{\prime })=\text{H}(s_{l,r})$

溢出与取模

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

• 使用 $2^{64}$ 进行取模，即直接使用 $unsignedlonglong$ 储存 $hash$ 值，产生溢出时相当于自动对 $2^{64}$ 进行取模
• 使用一个大质数进行取模

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

code

// acwing 兔子与兔子
#include 
// 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;
}

二维哈希

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

code

// UVa 11019
#include 
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