哈希表（模拟散列表 字符串哈希）

---

一、哈希表的概念

哈希表（又称为散列表），将一个比较大的值域映射到一个小的范围。

例如有哈希函数 h(x)，将区间$[-10^9,10^9]$的数字映射到$[0,10^5]$中。

方法：直接将 $x$ $mod$ $10^5$，但是这样会存在哈希冲突。

（冲突：两个数映射成了同一个数。）

$（取模的数尽可能是质数且与2的整次幂尽量远）$

（取质数是发生冲突概率最小的方法）

解决哈希冲突的方法：①开放寻址法 ②拉链法

类似于离散化，离散化保序，而哈希表不保序。离散化是一种极其特殊的Hash方式。

一般的操作有：

• 插入
• 查找
• 删除（算法题中一般不用）（通过给对应数打标记来实现）

哈希表的时间复杂度如下：

1. 插入（Insertion） 操作的平均时间复杂度是 $O(1)$。在理想情况下，插入一个元素到哈希表中只需要常数时间。然而，在发生哈希冲突（Hash Collision）时，需要处理冲突，可能会导致插入操作的时间复杂度略微增加，但仍然是常数时间的。

2. 查找（Lookup） 操作的平均时间复杂度是 $O(1)$。通过哈希函数计算出元素的哈希值，然后在哈希表中进行查找。在理想情况下，查找操作只需要常数时间。然而，如果存在哈希冲突，可能需要遍历哈希表中的某个桶（Bucket）来寻找目标元素，但由于哈希表的设计，这个遍历的代价也是常数时间的。

3. 删除（Deletion） 操作的平均时间复杂度是 $O(1)$。类似于插入和查找操作，在理想情况下，删除操作只需要常数时间。即使存在哈希冲突，也可以通过哈希函数计算出目标元素的位置，并进行删除。

需要注意的是，以上时间复杂度是基于平均情况的估计。在极端情况下，例如哈希函数设计不当或者存在大量的哈希冲突，哈希表的性能可能会下降，导致插入、查找和删除操作的时间复杂度接近O(n)，其中n是哈希表中存储的元素数量。

二、模拟散列表

题目

题目描述：
维护一个集合，支持如下几种操作:

1. I x，插入一个数 x；
2. Q x，询问数 x 是否在集合中出现过；

现在要进行 $n$ 次操作，对于每个询问操作输出对应的结果。

输入格式：
第一行包含整数 $n$，表示操作数量。
接下来 $n$ 行，每行包含一个操作指令，操作指令为I x，Q x中的一种。

输出格式：
对于每个询问指令Q x，输出一个询问结果，如果 x 在集合中出现过，则输出 Yes，否则输出 No。
每个结果占一行。

数据范围：
$1\le n\le 10^5$
$-10^9\le a\le 10^9$

输入样例：

5
I 1
I 2
I 3
Q 2
Q 5

输出样例：

Yes
No

代码实现

①拉链法

每个下列吊着的链表可以看作常数个，因此查询的时间复杂度大大降低。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

const int N = 1e5 + 3;
int h[N], idx, e[N], ne[N];
void insert(int x)
{
	int k = (x % N + N) % N;
	e[idx] = x;
	ne[idx] = h[k];
	h[k] = idx++;
}
bool query(int x)
{
	int k = (x % N + N) % N;
	for (int i = h[k]; i != -1; i = ne[i])
		if (e[i] == x) return true;
	return false;
}
int main()
{
	cin.tie(0);
	ios::sync_with_stdio(false);
	memset(h, -1, sizeof(h)); // 注意memset是以字节为单位来设置值
	int n;
	cin >> n;
	while (n--)
	{
		char op;
		int x;
		cin >> op >> x;
		switch (op)
		{
		case 'I':
			insert(x);
			break;
		case 'Q':
			if (query(x)) cout << "Yes" << endl;
			else cout << "No" << endl;
			break;
		default:
			cout << "error" << endl;
		}
	}
	return 0;
}

②开放寻址法

数组通常开到题目要求的数量的2~3倍（依旧找到对应的质数）
其原理相当于用空间换时间：要解决大量冲突会很费时间，开2~3倍可以减少冲突。

找到数组上对应的位置后，检测有没有被占用，有的话往后找位置放。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

const int N = 2e5 + 3;
int h[N], def = 0x3f3f3f3f; // 因为题目的数据范围是1e9,而0x3f3f3f3f大于1e9，所以可以用来做特殊值判断
int find(int x)
{
	int k = (x % N + N) % N;
	while (h[k] != def && h[k] != x)
	{
		k++;
		if (k == N) k = 0; // 如果找到了最后一个位置，那么就回到0
	}
	// 如果存在，返回x存储的位置
	// 如果不存在，返回x应该存储的位置
	return k;
}
int main()
{
	cin.tie(0);
	ios::sync_with_stdio(false);
	int n;
	cin >> n;
	memset(h, 0x3f, sizeof(h));
	while (n--)
	{
		int x, k;
		char op;
		cin >> op >> x;
		k = find(x);
		switch (op)
		{
		case 'I':
			h[k] = x;
			break;
		case 'Q':
			if (h[k] != def) cout << "Yes" << endl;
			else cout << "No" << endl;
			break;
		default:
			cout << "error" << endl;
		}
	}
	return 0;
}

三、字符串哈希

题目

题目描述：
给定一个长度为 $n$ 的字符串，再给定 $m$ 个询问，每个询问包含四个整数 $l_1,r_1,l_2,r_2$，请你判断 $[l_1,r_1]$ 和 $[l_2,r_2]$ 这两个区间所包含的字符串子串是否完全相同。

字符串中只包含大小写英文字母和数字。

输入格式：
第一行包含整数 $n$ 和 $m$，表示字符串长度和询问次数。

第二行包含一个长度为 $n$ 的字符串，字符串中只包含大小写英文字母和数字。

接下来 $m$ 行，每行包含四个整数 $l_1,r_1,l_2,r_2$，表示一次询问所涉及的两个区间。

注意，字符串的位置从 $1$ 开始编号。

输出格式：
对于每个询问输出一个结果，如果两个字符串子串完全相同则输出 Yes，否则输出 No。

每个结果占一行。

数据范围：
$1\le n\le 10^5$
$1\le m\le 10^5$

输入样例：

8 3
aabbaabb
1 3 5 7
1 3 6 8
1 2 1 2

输出样例：

Yes
No
Yes

思路

字符串哈希 $O(n+m)$

全称 字符串前缀哈希法，把字符串变成一个 $p$ 进制数字**（哈希值）**，实现不同的字符串映射到不同的数字。并且，用 $h[N]$ 记录字符串前 $N$ 个字符的 hash 值，类似于前缀和。

作用就是把 $O(N)$ 的时间复杂度降为 $O(1)$。比如本题就是对比任意两段内字符串是不是相同，正常就是类似于一个循环长度次的substr，其实用hash 差就能一步搞定。

例如：

str = "ABCABCDEYXCACWING";
h[0] = 0;
h[1] = "A"的Hash值;
h[2] = "AB"的Hash值;
h[3] = "ABC"的Hash值;
h[4] = "ABCA"的Hash值;

对形如$X_1,X_2,X_3,...,X_{n-1},X_n$的字符串，采用字符$ASCII$码乘上 $P$ 次方来计算哈希值。

映射公式：$(X_1\times P^{n-1}+X_2\times P^{n-2}+...+X_{n-1}\times P^1+X_n\times P^0)$ $mod$ $Q$

例如：
字符串 $ABCD$，$P=131$

那么 $h[4]=65\ast 131^3+66\ast 131^2+67\ast 131^1+68\ast 131^0$

而$AB$，$P=131$

说是$h[2]=65\ast 131^1+66\ast 131^0$

我们想要求 $CD$ 的$hash$值，怎么求呢？

就是 $h[4]-h[2]\ast 131^2$（意义在于将 $h[4$] 与 $h[2]$ 的字符串对齐再相减）

构建： $h[i]=h[i-1]\times P+s[i-1],i\in [1,n]$，其中$h$为前缀和数组，$s[i-1]$为字符串数组此位置字符对应的ASCII码。

应用： 查询 $l,r$ 之间部分字符串的 $hash=h[r]-h[l-1]\times P^{r-l+1}$

注意点

• 任意字符不可以映射成 $0$，否则会出现不同的字符串都映射成0的情况，比如：$A$，$AA$，$AAA$ 皆为 $0$。
• 冲突问题：通过巧妙（经验）设置 $P=131或13331$，$Q=2^{64}$，一般可以理解为不产生冲突（99.99%概率不冲突）。
• unsigned long long 的数值范围正好为$0$ ~ $2^{64}-1$，所以可以直接采用unsigned来接收数字，由于二进制的溢出特性，当 unsigned long long 下的最高位的进位 $1$ 溢出之后相当于除以 $2^{64}$。

代码实现

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

typedef unsigned long long ULL;

const int N = 1e5 + 10;
const int P = 131;
char str[N];
ULL h[N], p[N];

ULL get(int l, int r)
{
	return h[r] - h[l - 1] * p[r - l + 1];
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);
	int n, m;
	cin >> n >> m;
	cin >> str;

	p[0] = 1;
	for (int i = 1; i <= n; ++i)
	{
		p[i] = p[i - 1] * P;
		h[i] = h[i - 1] * P + str[i - 1]; // 由于str是从0开始的，所以读取时往后一格
	}

	while (m--)
	{
		int l1, r1, l2, r2;
		cin >> l1 >> r1 >> l2 >> r2;
		if (get(l1, r1) == get(l2, r2)) cout << "Yes" << endl;
		else cout << "No" << endl;
	}
	return 0;
}