数据结构——哈希表（模拟哈希表、字符串哈希）

1. 哈希表的定义
给定表M，存在函数f(key)，对任意给定的关键字值key，代入函数后若能得到包含该关键字的记录在表中的地址，则称表M为哈希(Hash）表，函数f(key)为哈希(Hash) 函数。
2. 哈希表的用途
把一个较大范围的值域映射到一个较小的范围
3. 哈希表的原理
通过对大数取余运算把一个大数映射到一个较小的范围，若取余结果有冲突则进行处理
4. 两种储存结构
根据对出现冲突时的不同处理方式，把哈希表分为两类：开放寻址法、拉链法
5. 两种模板

(1) 拉链法
    int h[N], e[N], ne[N], idx;

    // 向哈希表中插入一个数
    void insert(int x)
    {
        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;
    }

(2) 开放寻址法
    int h[N];

    // 如果x在哈希表中，返回x的下标；如果x不在哈希表中，返回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;
    }

6. 例题：模拟散列表
维护一个集合，支持如下几种操作：
1、“I x”，插入一个数x；
2、“Q x”，询问数x是否在集合中出现过；
现在要进行N次操作，对于每个询问操作输出对应的结果。

输入格式
第一行包含整数N，表示操作数量。

接下来N行，每行包含一个操作指令，操作指令为”I x”，”Q x”中的一种。

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

每个结果占一行。

数据范围
1≤N≤105
−10⁹≤x≤10⁹
输入样例：
5
I 1
I 2
I 3
Q 2
Q 5
输出样例：
Yes
No

开放寻址法题解
原理：把数组开成原本数据范围的2~3倍，如果有冲突就把冲突的数一次向后排

#include<iostream>
#include<cstring>

using namespace std;

//N为实际数据范围10^5的两倍，同样取质数
//null为在数据范围之外的一个大数，用于标记某个数组元素中是否为空
const int N = 200003, null = 0x3f3f3f3f;

int h[N];  //储存原数据

// 函数功能：查找某个数据在哈希表即（h[N]）中应该存放的下标
int find(int x)
{
	int k = (x % N + N) % N;
	
	while(h[k] != null && h[k] != x)
	{
		k++;
		if(k == N) k = 0;
	}

	return k;
}

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

	memset(h, 0x3f, sizeof(h)); 	//初始化哈希表，表中为空。因为memset是按位赋值，所以只赋值0x3f

	while(n--)
	{
		char op[2];
		int x;
		scanf("%s%d", op, &x);

		int k = find(x); //使k为x因该在表中的下标值，或者是表中存在x的下标值
		if(*op == 'I') h[k] = x;
		else 
		{
			if(h[k] != null) puts("Yes");
			else puts("No");
		}
	}
	return 0;
}					

拉链法题解
原理：在每个数组元素处拉一条单链表，存储不同的值

#include<iostrea>
#include<cstring>

using namespace std;

const int N = 100003;	//此处设为大于映射范围最小的质数，为了减少冲突

//h[N]存储所有链表头， 下标为原数据映射后的值
//e[N]存储链表数据， 即原数据
//ne[N]存储链表指针
//idx记录当前链表中节点的个数
int h[N], e[N], ne[N], idx;

//函数功能：在哈希表中插入一个数
void insert(int x)
{
	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[0] == 'I') insert(x);
		else 
		{
			if(find(x)) puts("Yes");
			else puts("No");
		}
	}

	return 0;
}		

7. 字符串哈希
（1）原理：把一个字符串看成一个P进制数，然后把它转化为10进制，再对他取余进行映射
（2）哈希步骤：
1.把一个字符串看成是131或13331进制的数（这样冲突概率小）
2.把这个p进制数转化为对应的10进制数
3.把转化后的10进制数对2⁶⁴取余，进行映射
（3）注意：不能把字母映射成0，因为如果是0那么A和AA都会是0；假定我们映射后的数不会发生冲突。
（4）代码步骤：

1. 预处理p[N]、h[N]，p[i]存储pⁱ，h[i]存储字符串前i个数的十进制数
   字符串前缀：h[i] = h[i-1] * P + str[i], 任意子串 = h[R] - h[L - 1] * P^R-L+1
2. 询问区间，比较两个区间对应的字符串的十进制数是否相等

8. 模板

核心思想：将字符串看成P进制数，P的经验值是131或13331，取这两个值的冲突概率低
小技巧：取模的数用2^64，这样直接用unsigned long long存储，溢出的结果就是取模的结果

typedef unsigned long long ULL;
ULL h[N], p[N]; // h[k]存储字符串前k个字母的哈希值, p[k]存储 P^k mod 2^64

// 初始化
p[0] = 1;
for (int i = 1; i <= n; i ++ )
{
    h[i] = h[i - 1] * P + str[i];
    p[i] = p[i - 1] * P;
}

// 计算子串 str[l ~ r] 的哈希值
ULL get(int l, int r)
{
    return h[r] - h[l - 1] * p[r - l + 1];
}

9.例题：字符串哈希
给定一个长度为n的字符串，再给定m个询问，每个询问包含四个整数 l1,r1,l2,r2 ，请你判断[ l1,r1 ]和[ l2,r2 ]这两个区间所包含的字符串子串是否完全相同。

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

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

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

接下来m行，每行包含四个整数 l1,r1,l2,r2 ，表示一次询问所涉及的两个区间。

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

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

每个结果占一行。

数据范围
1≤n,m≤105
输入样例：
8 3
aabbaabb
1 3 5 7
1 3 6 8
1 2 1 2
输出样例：
Yes
No
Yes

#include<iostream>

using namespace std;

typedef unsigned long long ULL; 

const int N = 100010, P = 131;

int n, m;
char str[N];
ULL h[N], p[N];	//用unsign long long 存储，如果结果溢出则相当于对2^64取余

//函数功能：计算任意子串的十进制值
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;				//计算p^i
		h[i] = h[i - 1] * P + str[i];		//计算字符串前缀对应的十进制数，此处str[i]可以取不为0的任意数
	}

	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;
}				

[^1] 注：此文章中的代码和模板均来自www.acwing.com