AcWing 841. 字符串哈希

题目描述

---

分析：

字符串 hash 小试牛刀

我们在之前模拟散列时，设置的哈希函数为将一个元素(element, e)输入哈希函数中，输出是一个整数，而那时的 $e$ 为一个有范围的整数。现在我们考虑更复杂的情形，$e$ 为一个字符串，为了区分，记为 $E$，字符串哈希函数就是将一个字符串 $E$ 映射为一个整数，使得该整数可以尽可能地代表一个字符串 $E$。
假设字符串 $E$ 由大写字母 $A-Z$ 和小写字母 $a-z$ 构成，在这个基础上，我们可以对字母进行编码：利用 $convert()$ 函数，将$A-Z$ 为 $1-26$，$a-z$ 为 $27-52$，举个例子 $convert(D)=4$。这样就把大小写字母对应到了五十三进制中。接着，按照将五十三进制转换为十进制的思路，由进制转换的结论可知，在进制转换中，得到的十进制是唯一的，由此便可将字符串映射成整数的需求。这里转换成的整数最大为 $53^{length}-1$（进制转换的基本性质），$length$ 为字符串的长度。实现代码如下：

// 哈希函数 h() 本质即为进制转化
int h(char* E)
{
	int ans = 0;
	for (int i = 0; E[i]; i ++)
	{
		if (E[i] >= 'A' && E[i] <= 'Z') ans = ans * 53 + (E[i] - 'A');
		else if (E[i] >= 'a' && E[i] <= 'z') ans = ans * 53 + (E[i] - 'a') + 26;
	}
	return ans;
}

假设字符串为"BCDE"，进行哈希映射后得到的整数为 $5\ast 53^0+4\ast 53^1+3\ast 53^2+2\ast 53^3$。从代码和样例中可以看出为什么我们在之前将 $A-Z$ 设为 $1-26$ 而不是 $0-25$，这是因为如果 “A” 为 $0$，那么 “AA”、“AAA” 都为 $0$ 了。

字符串 hash 进阶

对于上面的分析，我们可以总结出一个更系统的式子：

$S[i]=S[i-1]\ast p+E[i]$

其中 $p$ 为我们所采取的进制，$E[i]$ 表示字符串的第 $i$ 位是什么，$S[i]$ 表示字符串的前 $i$ 个字符的子串的 hash 值。这样，当 $i$ 取遍 $1-length$ 后，$S[length]$ 就是整个字符串的哈希值，而其他位置保存了部分字串的 hash 值。注意这里没有了 $convert()$ 函数，因为我们打算直接是用字符串字符的 ASCII 码 ，因此 $p$ 进制的选择就扑朔迷离了。
在转换过程中，字符串与整数是一一对应的，但由于没有适当的处理，当字符串字符较长时，产生的数会非常大，没办法用一般的数据类型存储。因此，按照之前对哈希的理解，要进行取模，即：

$S[i]=(S[i-1]\ast p+E[i])\%k$

通过这种方式可以把字符串转换成范围上能接受的整数。但这可能又产生另外的问题，也就是 hash值产生冲突。而根据y总的经验值，$p$ 取 $133$ 或 $13331$，$k$ 取 $2^{64}$，在 $99.99\%$ 的情况下是不会产生冲突的。因此这和普通哈希是有区别的，普通哈希是可以处理冲突的，而字符串哈希是不考虑冲突的（无法解决？）

子串的 hash值

考虑求解子串的 hash值，也就是求解 $S[l...r]$。由于上面介绍的取模运算在括号最外层，而我们接下来需要考虑括号内的问题，所以先暂时把取模运算放在一边，简化讨论。即：

$S[i]=(S[i-1]\ast p+E[i])$

子串的 hash值，$S[l...r]$ 实际上等于把字符串 $E[l...r]$ 从 $p$ 进制转换为十进制，也就是如下式子所表示的：

$S[l...r]=E[l]\ast p^{r-l}+E[l+1]\ast p^{r-l-1}+...+E[r]\ast p^0$

看到这个式子有没有觉得头大呢？没关系，这是很正常的，因为它有许多的参数需要理清，先看一个实例：

上面的 $S[l...r]$ 的公式可以通过 $S[j]$ 推导出：

$S[r]=S[r-1]\ast p+E[r]$
$=(S[r-2]\ast p+E[r-1])\ast p+E[r]$
$=S[r-2]\ast p^2+E[r-1]\ast p+E[r]$
$=...$
$=S[l-1]\ast p^{r-l+1}+E[l]\ast p^{r-l}+...+E[r]\ast p^0$
$=S[l-1]\ast p^{r-l+1}+S[l...r]$

移项可以得到：

$S[l...r]=S[r]-S[l-1]\ast p^{r-l+1}$

于是就得到了子串 $E[i...j]$ 的 hash值 $S[i...j]$，加上原来的取模操作可以得到：

$S[l...r]=(S[r]-S[l-1]\ast p^{r-l+1})\%k$

由于C++有 unsigned long long(ULL) 类型表示范围为$[0,2^{64}-1]$，因此当需要对 $2^{64}$ 取模时，可以用 ULL 类型存储该数，当出现溢出时就相当于进行了取模运算。

---

代码(C++)

#include <iostream>

using namespace std;

typedef unsigned long long ULL;

const int N = 100010, P = 131;
char E[N];
// POW 数组进行提前打表操作，i 中记录了 p^i
ULL H[N], POW[N];

//返回值为 ULL，相当于进行了取模运算
ULL subhash(int l, int r)
{
    // P 的 r-l+1 次幂，存储在对应下标中
    return H[r] - H[l - 1] * POW[r - l + 1];
}

int main()
{
    int n, m;
    // 对于字符串 E，从下标为 1 的位置读入
    scanf("%d%d%s", &n, &m, E + 1);
    
    POW[0] = 1;
    
    for (int i = 1; i <= n; i ++)
    {
        // H[i] 表示字符串前 i 个字符的子串 hash值
        H[i] = H[i - 1] * P + E[i];
        // 打表幂运算
        POW[i] = POW[i - 1] * P;
    }
    
    while (m --)
    {
        int l1, r1, l2, r2;
        scanf("%d%d%d%d", &l1, &r1, &l2, &r2);
        
        if (subhash(l1, r1) == subhash(l2, r2)) puts("Yes");
        else puts("No");
    }
    
    return 0;
}

代码(Python3)：

def sub(l, r):
    return (H[r] - H[l - 1] * POW[r - l + 1]) % (2 ** 64)


if __name__ == '__main__':
    n, m = map(int, input().split())
    N, P = 100010, 131
    E = input()
    
    H = [0] * N
    POW = [0] * N
    POW[0] = 1
    
    for i in range(len(E)):
        H[i + 1] = (H[i] * P + ord(E[i])) % (2 ** 64)
        POW[i + 1] = (POW[i] * P) % (2 ** 64)
        
    for _ in range(m):
        l1, r1, l2, r2 = map(int, input().split())
        if sub(l1, r1) == sub(l2, r2):
            print('Yes')
        else:
            print('No')

---