算法 - 字符串算法 - 字符串哈希算法介绍

介绍字符串中的哈希算法。

假设有 $n$ 个长度为 $L$ 的字符串，问其中最多有几个字符串是相等的。

直接比较两个长度为 $L$ 的字符串是否相等的时间复杂度是 $O(L)$ 的。因此需要枚举 $O(n^2)$ 对字符串进行比较，时间复杂度为 $O(n^2 L)$。如果我们把每个字符串都用一个哈希函数映射成一个整数。问题就变成了查找一个序列中的众数，时间复杂度变为了 $O(nL)$。

字符串哈希函数

注：本小节代码仅为演示，请不要实际运行。代码模板在下小节的代码实现中介绍。

一个设计良好的的字符串哈希函数可以让我们先用 $O(L)$ 的时间复杂度预处理，之后每次获取这个字符串的一个子串的哈希值都只要 $O(1)$ 的时间。这里重点介绍 BKDRHash。

BKDRHash 的基本思想就是把一个字符串当作一个 $k$ 进制数来处理。

代码如下：

const int HASH_K = 131;
const int HASH_M = 1e9 + 7;

int BKDRHash(char* str)
{
    int ans = 0;
    for (int i = 0; str[i]; ++i) {
        ans = (ans * HASH_K + str[i]) % HASH_M;
    }
    return ans;
}

例如，处理字符串 abac。

第一个循环，ans 为 $(97)$。

第二个循环，ans 为 $((97) * 19 + 98)$。

第三个循环，ans 为 $(((97)*19+98) * 19 + 97)$。

第四个循环，ans 为 $((((97)*19+98) * 19 + 97) * 19 + 99)$。

其中，模运算是为了保证运算过程中数的范围，防止指数爆炸。且 HASH_K 和 HASH_M 最好取成质数，这样可以减少哈希冲突。

现在我们考虑子串的哈希，假设字符串 $s$ 的下标从 $1$ 开始，长度为 $n$，我们得到 $s[1..i]$ 的 BKDRHash 值 ha[i]。令哈希函数为 $\text{hash}$，则有定义

$$ha[i] := \text{hash}(s[1..i])$$

计算代码如下：

const int HASH_K = 131;
const int HASH_M = 1e9 + 7;

p[0] = 1;
ha[0] = 0;
for (int i = 1; i <= n; ++i) {
    p[i] = p[i - 1] * HASH_K;
    ha[i] = (ha[i - 1] * HASH_K + s[i]) % HASH_M;
}

现在询问 $s[x..y]$ 的 BKDRHash 可以得到（加的括号仅是为了方便展示后面得到的关系）

$$ha[y] = s[1]k^{y-1} + s[2] k^{y-2} + \cdots + s[x-1]k^{y-x+1} + (s[x] k^{y-x} + \cdots + s[y]), \quad y \geqslant 1 \tag{1}$$

又注意到

$$ha[x-1] = s[1] k^{x-2} + s[2] k^{x-3} + \cdots + s[x-1], \quad x \geqslant 2 \tag{2}$$

而我们要求的 $s[x..y]$ 的哈希值为

$$\text{hash}(s[x..y]) = s[x] k^{y-x} + \cdots + s[y] \tag{3}$$

可以发现得到如下关系式

$$\text{hash}(s[x..y])=ha[y]-ha[x-1]k^{y-x+1} \tag{4}$$

因此我们预处理出 ha 数组和 $k$ 的幂次 p 数组，之后每次询问 $s[x..y]$ 的哈希值，只要 $O(1)$ 的时间。

哈希函数代码实现

每次迭代后取模

如果我们按照我们上面推导的公式表述的式子做代码实现，会带来一个问题：指数爆炸。即 $k$ 的幂次可能很高，以致超出了 C 语言的数据表示范围。因此我们需要每迭代一次，就对结果取一次模，就像上节的代码展示的那样，但这需要重新计算关系式 $(4)$。

每一步的迭代表示为

$$ha[i] = (ha[i-1] * k + s[i]) \% P \tag{5}$$

注意到上式参与计算的数都大于等于 $0$，因此计算机上的 $\%$ 与数学上的 $\bmod$ 一致，此时 对任意 $a,b \geqslant 0$ 有性质

$$(a \% P * k) \% P = (a * k) \% P \tag{6}$$

$$(a + b) \% P = (a \% P + b \% P) \% P \tag{7}$$

上述性质可参见相关的数学教材即可，或者自己尝试证明也行，并不困难。由式 $(6)$ 和式 $(7)$ 可将我们要计算哈希值的表达式进行化简

$$\begin{align*} \text{hash}(s[l..r]) & = (⋯((0*k+s[l]) \%P * k+s[l+1]) \%P * k + ⋯) \%P * p+s[r]) \%P \\ & = (s[l] * k^{l-r} + s[l+1] * k^{l-r-1} + s[r]) \% P \end{align*} \tag{8}$$

可将 $ha[r] := \text{hash}(s[1..r])$ 和 $ha[l-1]$ 看作上式的特例，因此我们得到了 $ha[r]$ 和 $ha[l-1]$ 的结果，此时你应该会发现这些结果与 $(1)-(4)$ 非常相似，你也许会认为有下式成立

$$\text{hash}(s[l..r]) = (ha[r]-ha[l-1]*k^{r-l+1}) \% P \tag{9}$$

但是并不正确，因为式 $(9)$ 中的 $ha[r]$ 和 $ha[l-1]$ 是由式 $(5)$ 迭代产生的，两者相减可能为负，而被除数为负数，除数为正数时，产生的余数会不一致（数学上与 C 语言上的模运算，见链接）。我们只需将式 $(9)$ 调整为

$$\text{hash}(s[l..r]) = ((ha[r]-ha[l-1]*k^{r-l+1}) \% P + P) \% P\tag{10}$$

式 $(10)$ 就是最终得到的关系式，利用该关系式，仍然可在 $O(1)$ 时间内计算子串的哈希值。

数据溢出与数据表示范围

在我们循环过程中，我们计算如下语句

ha[i] = (ha[i - 1] * HASH_K + s[i]) % HASH_M;

会出现的一种情况是，在计算 ha[i - 1] * HASH_K + s[i] 过程中，数据过大导致数据溢出，相当于对计算结果做了一次模运算。如果你构造哈希函数时就用的是数据的自然溢出来作为模运算，那计算过程中导致的溢出并不影响最终结果；但若不是如此，很可能导致哈希值计算不正确。

因此一般要开数据范围在 long long，且 HASH_K 和 HASH_M 值要保证不发生溢出。

举一个例子，取 HASH_K 为 131，取 HASH_M 为 1e9+7，由于每次迭代后都取模，因此保证了 ha[i - 1] 不超过 1e9+7，即使之后每次运算都尽量取到最大，也能保证计算过程 ha[i - 1] * HASH_K + s[i] 未溢出（都在 long long 的数据范围内）。

双哈希减小冲突

在计算一个字符串的哈希值的过程中，用两个不同的 $k$ 和两个不同的模数 $m$ 分别运算，将这两个结果用一个二元组表示，作为哈希的结果。

即每一步迭代产生两个哈希

$$ha_1[i] = (ha_1[i-1] * k_1 + s[i]) \% P_1$$

$$ha_2[i] = (ha_2[i-1] * k_2 + s[i]) \% P_2$$

此时将二元组作为哈希的结果，即

$$\text{hash}(s[1..i]) = <ha_1[i], ha_2[i]>$$

给定一个子串，计算其哈希，就是对该子串按式 $(10)$ 分别做两次哈希，然后将这两个哈希值组合为二元组的结果。