哈希表

哈希表

存储结构

把一堆复杂的数映射到从 $0\sim n(0\le n\le 10^{5\sim 6})$

$e.g.$ 把从 $0\sim 10^9$ 的这样一堆数映射到从 $0\sim 10^5$ 大小的数据结构中，在一个比较大的值域中选择一些数插入，选择一些数查询

1. 哈希函数：$x\mathrm{m}\mathrm{o}\mathrm{d}10^5$ 这样 $x$ 的范围就在 $0\sim 10^5$ 之间了 （注意：模数一定要是质数，并且要离 $2$ 的整数次幂尽可能远）
2. 处理冲突（把两个不一样的数映射成了同一个数）
3. 注：离散化是及其特殊的哈希方式 $h(x)$ 要单调递增

两种哈希方法

1. 开放寻址法

2. 拉链法：将冲突的数形成一条链

操作：添加、查找、删除（打一个标记标记它被删除）

时间复杂度

哈希表是一种期望算法，每一条链的长度可以看成常数，所以一般而言，哈希函数的时间复杂度都比较好 $O(1)$

Code

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> PII;
#define debug(a) cout << #a << " " << a << endl
const int maxn = 1e5 + 7;
const int N = 100003, M = N * 2;
const int inf = 0x3f3f3f3f;
const long long mod = 1e9 + 7;

int h[N], e[N], ne[N], idx;

void insert(int x) {
	//为了保证k是一个正数k的值要加上 N N取大于100000的第一个质数 -> 由数据范围得出
	int k = (x % N + N) % N; //k是哈希值
	e[idx] = x, ne[idx] = h[k], h[k] = idx++;
}

bool find(int x) {
	int k = (x % N + N) % N;
	for(int i = h[k]; i != -1; i = ne[i]) {
		int j = e[i];
		if(j == x) {
			return true;
		}
	}
	return false;
}

int main() {

//	freopen("input.txt", "r", stdin);
//	freopen("output.txt", "w", stdout);

//	ios::sync_with_stdio(false);
	memset(h, -1, sizeof h);
	int n;
	scanf("%d", &n);
	for(int i = 1; i <= n; i++) {
		char op[2];
		int x;
		scanf("%s%d", op, &x);

		if(op[0] == 'I') insert(x);
		else {
			if(find(x)) puts("Yes");
			else puts("No");
		}

	}


	return 0;
}

一个常用的字符串哈希方式

定义 $h(x)$ 表示前 $x$ 个字符的哈希值

1. 把这个字符串看成是一个 $p$ 进制的数
2. 通过等式变形把 $p$ 进制的数变成 $10$ 进制的数，最后对整个数 $\mathrm{m}\mathrm{o}\mathrm{d}Q$
3. 这样就把任何一个字符串映射到从 $0\sim Q-1$ 之间的一个数

注意

1. 不能映射成数字 0
2. 字符串哈希假定了不存在冲突，不考虑冲突的问题，哈希的经验值：当 $p=131/13331$ 时，$Q=2^{64}$ ，在一般情况下不会出现冲突

优势

利用求得的前缀哈希用一个公式计算所有子段的哈希值

例子

假设有 $|S|=5$ 的字符串，设 $S_i$ 为第 $i$ 个字符，其中$1\le i\le 5$

根据定义分别求出hash[i]

$hash[1]=s1$
$hash[2]=s1\ast p+s2$
$hash[3]=s1\ast p2+s2\ast p+s3$
$hash[4]=s1\ast p3+s2\ast p2+s3\ast p+s4$
$hash[5]=s1\ast p4+s2\ast p3+s3\ast p2+s4\ast p+s5$

现在我们想求s3s4的hash值，不难得出为s3∗p+s4,并且从上面观察，如果看hash[4]−hash[2]并将结果种带有s1,s2系数的项全部消掉，就是所求。但是由于p的阶数，不能直接消掉，所以问题就转化成，将hash[2]乘一个关于p的系数，在做差的时候将多余项消除，从而得到结果。

不难发现，对应项系数只差一个p2，而4 - 3 + 1 = 2(待求hash子串下标相减再加一)，这样就不难推导出来此例题的求解式子。

hash[4]−hash[2]∗p4−2+1
至此，通过对上例的归纳，可以得出如下的公式。

公式
若已知一个 $|S|=n$ 的字符串的hash值，$hash[i],1\le i\le n$，其子串 $sl..sr,1\le l\le r\le n$ 对应的hash值为：

$hash=hash[r]-hash[l-1]\times p^{r-l+1}$

考虑到 $hash[i]$ 每次对 $p$ 取模，进一步得到下面的式子：

$hash=(hash[r]-hash[l-1]\times p^{r-l+1})\mathrm{m}\mathrm{o}\mathrm{d}MOD$

看起来这个式子人畜无害，但是对于取模运算要谨慎再谨慎，注意到括号里面是减法，即有可能是负数，故做如下的修正：

$hash=((hash[r]-hash[l-1]\times p^{r-l+1})\mathrm{m}\mathrm{o}\mathrm{d}MOD+MOD)\mathrm{m}\mathrm{o}\mathrm{d}MOD$

至此得到求子串hash值公式。

值得一提的是，如果需要反复对子串求解hash值，预处理 $p$ 的 $n$ 次方效果更佳。

Code

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> PII;
#define debug(a) cout << #a << " " << a << endl
const int maxn = 1e5 + 7;
const int N = 1e6 + 7, M = N * 2,P = 131;
const int inf = 0x3f3f3f3f;
const long long mod = 1e9 + 7;
inline long long read();

int n, m;
char str[N];
ull h[N], p[N]; //p数组存储p的多少次方

// 使用ull存储 因为ull正好最大值为2的64次方相当于取模
ull get(int l, int r) {
	return h[r] - h[l - 1] * p[r - l + 1];
}

int main() {

//	freopen("input.txt", "r", stdin);
//	freopen("output.txt", "w", stdout);

//	ios::sync_with_stdio(false);
	scanf("%d%d%s", &n, &m, str + 1);

	p[0]=1;
	for(int i = 1; i <= n; i++) {
		p[i] = p[i - 1] * P; //预处理 p 的次幂
		h[i] = h[i - 1] * P + str[i];//字符串前缀数组 
	}

	while(m--) {
		int l1, r1, l2, r2;
		scanf("%d%d%d%d", &l1, &r1, &l2, &r2);

		if(get(l1, r1) == get(l2, r2)) {
			puts("Yes");
		} else {
			puts("No");
		}
	}

	return 0;
}


/*
数组开够了吗 开到上界的n+1次方
初始化了吗
*/







inline ll read() {
	char ch = getchar();
	ll p = 1, data = 0;
	while(ch < '0' || ch > '9') {
		if(ch == '-')p = -1;
		ch = getchar();
	}
	while(ch >= '0' && ch <= '9') {
		data = data * 10 + (ch ^ 48);
		ch = getchar();
	}
	return p * data;
}