哈希表

哈希表存储结构

• 最常用的两类：开放寻址法、拉链法

模拟散列表

拉链法

#include <iostream>
#include <cstring>

using namespace std;

//做hash时整个数组的长度取成质数，同时这个数离2的幂次最远
const int N = 100003;  

//寻找大于100000的第一个质数
// for(int i = 100000; ; i ++ ) {
// 	bool flag = true;
// 	for(int j = 2; j * j <= i; j ++ ) {
// 		if(i % j == 0) {
// 			flag = false;
// 			break;
// 		}
// 	}
// 	if(flag) {
// 		cout << i << endl;
// 		break;
// 	}
// }

//开一组hash槽，每个槽上拉一个链表
int h[N], e[N], ne[N], idx;

//插入
void insert(int x) {
	//c++中负数取模是负数，这样处理可以将所有结果映射到正数
	//h[k]存储的是拉链中第一个点的下标
	int k = (x % N + N) % N;
	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])
		if(e[i] == x)
			return true;

	return false;
}

int main() {
	int n;
	scanf("%d", &n);
	memset(h, -1, sizeof h); //
	
	while(n -- ) {
		char op[2];
		int x;
		scanf("%s%d", op, &x);

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

	return 0;
}

// memset 函数是内存赋值函数，用来给某一块内存空间进行赋值的；
// 包含在<string.h>头文件中,可以用它对一片内存空间逐字节进行初始化；
// 原型为 ：void *memset(void *s, int v, size_t n);
// 这里s可以是数组名，也可以是指向某一内在空间的指针；
// v为要填充的值；
// n为要填充的字节数

开放寻址法

//处理冲突的思路类似“上厕所”
#include <cstring>
#include <iostream>

using namespace std;

//一般开两倍空间
const int N = 200003, null = 0x3f3f3f3f;

int h[N];

//找到x所在的位置
//如果目标数已经存在，返回该位置
//如果目标数不存在，返回应该插入的位置
int find(int x)
{
    int t = (x % N + N) % N;
    while (h[t] != null && h[t] != x)
    {
        t ++ ;
        if (t == N) t = 0;
    }
    return t;
}

int main()
{
    memset(h, 0x3f, sizeof h);

    int n;
    scanf("%d", &n);

    while (n -- )
    {
        char op[2];
        int x;
        scanf("%s%d", op, &x);
        if (*op == 'I') h[find(x)] = x;
        else
        {
            if (h[find(x)] == null) puts("No");
            else puts("Yes");
        }
    }

    return 0;
}

字符串哈希

• 很多字符串相关问题都可以用字符串哈希来处理，不一定用kmp

字符串哈希

//注意：1）不能映射成0； 2）假定不存在冲突情况
//预处理成前缀哈希，用“p进制法”
//可以用前缀哈希快速求得任意子串的哈希
#include <iostream>

using namespace std;

//将哈希值定义成无符号数，可以自动处理大整数溢出的情况
typedef unsigned long long ULL;

//P表示进制，去131这个经验值
const int N = 100010, P = 131;

int n, m;
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() {
	scanf("%d%d%s", &n, &m, str + 1);

	p[0] = 1;
	for(int i = 1; i <= n; i ++ ) {
		p[i] = p[i - 1] * 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;
}