哈希表是一种期望算法。
一般情况下，哈希表的时间复杂度是 O(1)。
作用
将一个复杂数据结构映射到一个较小的空间 0~N（10^5~10^6），最常用的情景：将 0~10^9 映射到 0~10^5。
离散化是一种及其特殊的哈希方式。离散化是需要保序的，是要求单调递增的。
映射的方法叫做哈希函数。
哈希函数
取模
x mod 10^5将 x 映射到 0~10^5 中。
模数的选择
模的数一般取质数，即 mod 后面的数一般取质数，并且距离2的整数次幂远，这样取冲突的概率最小【由此可以确定映射数组的长度】。
做题时，选择超过数据范围的第一个质数。
存在冲突
因为 x 的定义域比较大，而映射到的值域比较小，就可能将若干不同的数映射为一个相同的数，产生冲突。
处理方式
- 开放寻址法
- 拉链法：每个哈希表中的元素都是一个链表的头节点。每当将一个值映射到某个空间，那就将这个值放在该空间所代表的链表中。
存储结构
拉链法
处理冲突
h(x)∈(0,10^5)，开一个宽度为10^5的数组，数组下标是0~10^5-1。{ 将映射的数组当成一个槽，在槽上拉链，如果两个数是冲突的，那么就用一条链将其相连，该链就是单链表 }h(a)=b【将a映射为b】，就在数组下标为b的元素上拉一条链，用于存储a；h(c)=b【将c映射为b】，在数组下标为b的元素的链上再存上c【在该链的末尾和开头增加都可以】。
哈希表是一种期望算法， 从平均情况上看，每条链的长度可以看成一个常数，一般情况下，哈希表的时间复杂度是 O(1)。
操作
一般只有添加、查找操作，没有删除操作。
数据
h，映射得到的数组，数组中每个元素作为该槽对应的单链表的头指针存在
e，单链表的数据域
ne，单链表的指针域
idx，存储当前已经用到哪个点
添加
添加 x，先求 h(x)，根据 h(x) 确定 x 对应的槽【将 h(x) 作为下标查找哈希表中对应的链表】，然后将 x 插到该槽对应的链【单链表】上。
为什么不直接int k=x%N?
如果这样，正数取模结果是一个正数，负数取模结果是一个负数。先取模再加N，使得结果一定是一个正数，然后再取模，这样无论是正数还是负数取模的结果都是正数。
void insert(int x){
int k=(x%N+N)%N;
e[idx]=k;
ne[idx]=h[k];
h[k]=idx;
idx++;
}查找
查找 x，先求h(x)，确定 x 对应的槽，然后遍历该槽对应的链表，查看链表中是否存在 x 即可。
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;
}删除
算法中要实现删除操作，不会真的将该点删除。一般情况是开一个数组，在每个点上做一个标记，比如使用 bool 变量。
开放寻址法
只开一个一维数组，该数组的长度要达到题目要求的 2~3 倍【经验值】，此时冲突的概率比较低。这样会导致在查找时在遍历完数组一遍之前一定会停止，不会一直找下去。
处理冲突
h(x)=k，先查看数组中下标为 k 个位置是否被占用，若无，自己占用，若有，去下一个位置，直到找到一个未被占用的位置将其占用。
操作
memset(h,0x3f,sizeof h);为什么不初始化为0x3f3f3f3f?
按字节memset，不是按数memset，h是int型数组，有四个字节，每一个字节都是0x3f，一共有4个字节，就是0x3f3f3f3f。
寻找位置
若x在哈希表中存在，返回其所在位置，不存在返回其应该存储的位置。
若是查找途中越界，则应该从数组开头继续找，直到整个数组遍历了一遍。
int find(int x){//若x在哈希表中存在，返回其所在位置，不存在返回其应该存储的位置
int k=(x%N+N)%N;
while(h[k]!=null&&h[k]!=x){
k++;
if(k==N)//看完最后一个位置，回到数组开头
k=0;
}
return k;
}添加
添加 x，x 通过哈希函数计算得到哈希值，将其作为我们所期望的下标，若存在冲突，向后查看，找到后面第一个没有被占用的位置，将数据 x 放入。
int k=find(x);
h[k]=x;
查找
查找 x，x 通过哈希函数计算得到哈希值，将其作为我们所期望的下标进行查找，若当前位置没有数据，则数据不存在，若该位置有数据且是所要查找的值，则查找成功，若该位置有数据但不是所要查找的值，则继续向后进行遍历查找，直到没数据或找到数据为止。若是查找途中越界，则应该从数组开头继续找，直到整个数组遍历了一遍。
int k=find(x);
if(h[k]!=null)
puts("Yes");
else
puts("No");
删除
删除 x，与拉链法类似，按查找的方式找 x，找到后做标记即可。
例题——模拟散列表
题目描述
维护一个集合，支持如下几种操作：
I x，插入一个数 x；Q x，询问数 x 是否在集合中出现过；
现在要进行 N 次操作，对于每个询问操作输出对应的结果。
输入格式
第一行包含整数 N ，表示操作数量。
接下来 N 行，每行包含一个操作指令，操作指令为 I x，Q x 中的一种。
输出格式
对于每个询问指令 Q x，输出一个询问结果，如果 x 在集合中出现过，则输出 Yes，否则输出 No。
每个结果占一行。
数据范围
1 ≤ N ≤ 10^5
−10^9 ≤ x ≤ 10^9
输入样例
5
I 1
I 2
I 3
Q 2
Q 5
输出样例
Yes
No
拉链法
#include<iostream>
#include<cstring>
using namespace std;
const int N=100003;//是质数且距离2的整数次幂远
int h[N];//开的槽
int e[N],ne[N],idx;//链表
void insert(int x){
int k=(x%N+N)%N;
e[idx]=k;
ne[idx]=h[k];
h[k]=idx;
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");
}
}
}开放寻址法
#include<iostream>
#include<cstring>
using namespace std;
const int N=200003;//是质数且距离2的整数次幂远
const int null=0x3f3f3f3f;//约定：数组元素值为0x3f3f3f3f时，该位置为空
int h[N];
//若x在哈希表中存在，返回其所在位置，不存在返回其应该存储的位置
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
while(n--){
char op[2];
int x;
scanf("%s%d",op,&x);
int k=find(x);
if(op[0]=='I'){
h[k]=x;
}
else{
if(h[k]!=null)
puts("Yes");
else
puts("No");
}
}
return 0;
}字符串哈希方式
字符串前缀哈希法
先预处理出字符串所有前缀的哈希值，h[0] 具有特殊含义，表示前0个字符的哈希值，h[n] 表示前n个字符的哈希值。之后可以使用前缀的哈希值使用 O(1) 的时间复杂度算出任意一个子串的哈希值。
字符串前缀哈希值的定义方式
将字符串看成 p 进制的数，字符串的每一个字符当作 p 进制数的每一位数字，再将该 p 进制的数换算为一个十进制的数，因此可将整个字符串转化为一个特别大的数，然后再将该数模上一个比较小的数 Q，通过取模就可将该数映射到 0~Q-1 之间的一个数。
注意
- 一般情况下，不将要字母映射为 0，避免产生冲突【例如，将‘A’映射为0，那么字符串“A”的 p 进制是 0，转化为十进制也是 0；字符串“AA”的 p 进制是 0，转化为十进制也是 0，会产生冲突】。
原因：若该字母映射为0，那一个完全由该字母组成的字符串，无论有多少位，他的hash值始终是0，会冲突。
- 假定 Rp 足够好，不存在冲突
当 P=131 或 P=13331，Q=264 时，一般不会存在冲突。
- 其实字母映射的值不重要
其实字母映射出来的值具体是什么其实不重要，进制数主要是用于求取hash值的。所以无论是字母还是数字，只要保证两个不同的字母或数字，二者对应的整型值不同，那将该值对应的整型直接利用即可。·
求前缀子串的哈希值
h[0]=0;
h(i)=h(i-1)*P+str[i];//字母从下标为1开始存储
作用
可以利用前缀哈希，利用一个公式算出任意一个子串的哈希值。
如何求区间[L,R]子串的哈希值？
字符串下标从1开始，已知 1~L-1【h[L-1]】和 1~R【h[R]】的哈希值。
左边是高位，右边是低位。在 h[R] 中，R是第0位，1是第R-1位；在 h[L-1] 中，L-1是第0位，1是第L-2位。
将 h[L-1] 这一段向左移，移到和 h[R] 对齐为止，即 h[L-1]*pR-L+1 ，则区间 [L,R] 子串的哈希值是 h[R]-h[L-1]*pR-L+1 。
直接使用 unsigned long long 存储所有哈希值，就不需要取模了，溢出就相当于取模【溢出等价于模上264】。
预处理完所有前缀的哈希值之后，就可以使用 O(1) 的时间复杂度算出任意一个子串的哈希值。
为什么h[R] - h[L-1]*pR-L+1可以求出[L,R]子串的hash?
因为(a - b) % c == (a%c - b%c) % c
[L,R]子串就是R子串的hash - L子串hash*(p的R-L差值之幂)
为什么不需要取模？
由于unsigned long long 自动取模，所以可用此公式求出子串hash。
例题——字符串哈希
#include<iostream>
using namespace std;
typedef unsigned long long ULL;
const int N=100010,P=131;
char str[N];
ULL h[N],p[N];//p数组用来存储p的多少次方
int n,m;
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];//因为映射字母成多少都无所谓，所以可以直接使用ASCII码
}
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;
}
