哈希
哈希表：将大而复杂的数据映射到紧凑的区间内。分为：①存储结构
（离散化是特殊的哈希，之前讲的离散化是严格保序的 映射到区间上是连续递增的）
哈希不保序，这里讲的是一般的哈希
弊端：若数据的数值较大可以对其取模后再映射，但是取模后可能造成：
之前不相同的数值取模后映射到同一位置上了，所以引入：开放寻址法，拉链法
①存储结构
{
1（开放寻址法
{
添加：
开一个一维数组h[]，长度一般要开到题目要求长度的2到3倍
1'假设a取模后的值为k，那么就将a放到h[k]上
2'若b取模后的值仍为k，那么就将b放到h[k+i]上（即向后遍历，直到找到一个没存放数值的h[k+i]为止）
注意：由于这里数组h[ ]的长度为题设要求的2~3倍，所以一定能找到一个位置满足上述1’，2’两种情况
...
查找：
如果当前h[k]存在并且h[k]==x那么就找到了，如果！=x那么就继续向下寻找
如果当前h[k]不存在，那么就不需要向下寻找，即x不存在
删除：
不真正的删除，而是开一个bool类型的数组，将所要删除的数值标记一下
后续在查询、添加操作时，对此值是否存在特判一下即可
题目：840. 模拟散列表 - AcWing题库
代码：
暴力+二分，样例11/16：
#include<bits/stdc++.h>
using namespace std;
const int N=1e5+50;
int f[N];
int main()
{
int n,i=0;
scanf("%d",&n);
while(n--)
{
char op[5];
int x;
scanf("%s %d",op,&x);
if(!strcmp(op,"I"))
{
f[i]=x;
i++;
}
else
{
sort(f,f+i);
int l=0,r=i-1;
while(l<r)
{
int mid=l + r +1 >> 1;
if(f[mid]>x) r=mid-1;
else l=mid;
}
if(f[l]==x) cout << "Yes" << endl;
else cout << "No" << endl;
}
}
return 0;
}哈希：
#include<iostream>
//memset()函数所在头文件
#include<cstring>
using namespace std;
int n;
const int N=2e5+3,null=0x3f3f3f3f;
int h[N];
//如果x在hash表中已经存在的话，就返回x在hash表中所在的位置
//如果不存在的话就返回x应该在hash表中存储的位置
int find(int x)
{
int k=(x%N + N)%N;
while(h[k]!=null && h[k]!=x)
{
k++;
//如果k==N的话（最边缘），那么就让它从头开始寻找
//由于N的长度为题解要求的2倍，所以一定能找到一个k
//这个k要么是x在hash表中的位置，要么是它可以在hash表中存在的位置
if(k==N) k=0;
}
return k;
}
int main()
{
scanf("%d",&n);
memset(h,null,sizeof h);
while(n--)
{
char op[2];
int x;
scanf("%s %d",op,&x);
int k=find(x);
if(!strcmp(op,"I")) h[k]=x;//直接记录下x可以在hash表中插入的位置
else
{
//如果x存在于hash表中，那么一定不等于null
//如果不存在于hash表中，那么k所返回的值就是x可以在hash表中存在的位置
//但是由于这一步是查询操作，所以h[k]==null（null是初始值）
if(h[k]!=null) cout << "Yes" << endl;
else cout << "No" << endl;
}
}
return 0;
}}
2（拉链法
{
添加：
开一个一维数组a[]存下所有数值，将数值a取模后的值（假设是3），
就在数组a[3]的后面 “拉一条链” 将a链住
如果又有数值b取模后仍等于3，那么就在数值a的后面再“拉一条链”将数值b链住
（每个数组a[]下对应的链就是我们之前所学的单链表）
插入过程与前面链表的插入过程一致，可翻阅查看：.单链表.-CSDN博客
...
查找：
求出数值取余后对应的是数组a[]上的那一个值，再询问此a[]上的链表是否有所要求的数值
删除：
不真正的删除，而是开一个bool类型的数组，将所要删除的数值标记一下
后续在查询、添加操作时，对此值是否存在特判一下即可
代码：
#include<iostream>
//memset()函数所在头文件
#include<cstring>
using namespace std;
int n;
const int N=1e5+3;
int h[N],e[N],ne[N],idx;
void insert(int x)
{
//取模，映射到数组h[]上,x可能为负数，所以先模再加 之后再次取模
int k=(x%N+N)%N;
e[idx]=x,ne[idx]=h[k],h[k]=idx,idx++;
}
bool find(int x)
{
int k=(x%N + N)%N;
//遍历链表h[k]（链表上的第一个下标）表示数组上下标为k的下一个指向
//每次让i指向它的下一个指向（移动指针i，使其继续向下遍历）
//i=-1时即遍历结束（空值）
for(int i=h[k];i!=-1;i=ne[i])
if(e[i]==x)
return true;
return false;
}
int main()
{
scanf("%d",&n);
memset(h,-1,sizeof h);
while(n--)
{
char op[2];
int x;
scanf("%s %d",op,&x);
if(!strcmp(op,"I")) insert(x);
else
{
if(find(x)) cout << "Yes" << endl;
else cout << "No" << endl;
}
}
return 0;
}
}
取模的值：
上述的N分别取的是N=2e5+3、1e5+3这里不像之前取1e5+10是因为：N是取模的值
取模的值一般满足以下规律使映射时的重复率最低：（取模的数值一般取成质数并且离2的整次幂要远的多）
计算方法：
（取模的数值一般取成质数并且离2的整次幂要远的多）
{
//本题的操作次数不大于100000，所以从100000开始遍历（根据题设要求来初始化i）
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;
}
}
return 0;
//这里输出的i就是接下来要取模的数值
}②字符串哈希方式
字符串hash方式
这里讲的是特殊的hash方式：字符串前缀哈希法
类似于前缀和：
{
str="abcacwing",str[0]=0（特殊处理），str[1]="a",str[2]="ab",
str[3]="abc",str[4]="abca"...
定义某一个哈希的前缀和：把这个字符串看成是p进制的数
每一位字母（str[i]）看成是在p进制下的数字
如果字符串str[4]="abcd"，分别在p进制下，a：1，b：2，c：3，d：4
那么str[4]在p进制下的和即为：1*p^3+2*p^2+3*p^1+4*p^0，
这样处理就可以把字符串转化成一个数字
但这个数字可能较大，所以mod（%）上一个数Q，那么就可以把这个大的数字映射成1~Q-1之内的数字了。
接下来通过比较数值大小即可比较两个字串是否相同。
注意：①：不能映射成0，因为0在任何进制下的值都为0，那么字符串：aasxas,axssx,cbdhd都会被映射成0
②：这里是假设不存在冲突，不存在重复的情况。当p=131或者13331，Q=2^64时，基本上不存在冲突
若要模上Q（2^64）那么可以直接用unsigned long long 来存储hash值，溢出的值就是模上2^64的值。
}
这样处理的好处就是可以利用前缀哈希，来确定任意字串的哈希值
{
这里的左边（1）是高位，右边（R）是低位（进制情况下最左边为最低位，即最左边*P^0）。所以在h[R]中R就是第0位，1就是第R-1位，h[l-1]中l-1就是第0位，1就是第l-2位。
那么如果要求L到R之间字串的hash值，那么就先要将h[l-1]的0位与h[R]的第0位对齐
这里R在l的右边，所以改变h[l-1]的0位与h[R]的第0位对齐
（不对齐0位，由于不同数位对应不同P的幂，那将导致相减毫无意义）
比如：1*p^3+2*p^2+3*p^1+4*p^0，数位a对应的是P^3,b对应的是P^2.. 即将h[l-1]*((P^(R-1))/(P^(l-2))
}
也就是达到数位对齐的目的：字符串ABCDE 与 ABC 的前三个字符值是一样，只差两位，
乘上P的二次方把 ABC 变为 ABC00，再用 ABCDE - ABC00 得到 DE 的哈希值。
最终所推得的公式：
子串的hash值为①：h[R]-h[l-1](P^(R-L+1));
所以最终任意字符串的hash值为②：h[i]=h[i-1]*P + str[i];
公式①：
公式②：
题目：841. 字符串哈希 - AcWing题库
代码：
暴力+双指针，样例：8/13：
#include<iostream>
using namespace std;
int main()
{
int m,n;
scanf("%d %d",&m,&n);
char str[100050];
scanf("%s",str);
while(n--)
{
int x1,y1,x2,y2;
scanf("%d %d %d %d",&x1,&y1,&x2,&y2);
bool flag=true;
while(x1<=y1 && x2<=y2)
{
if(str[x1-1]!=str[x2-1] ||str[y1-1] != str[y2-1])
{
flag=false;
break;
}
else x1++,x2++,y1--,y2--;
}
if(flag) printf("Yes\n");
else printf("No\n");
}
}哈希字符串：
#include<bits/stdc++.h>
using namespace std;
typedef unsigned long long ULL;
const int N=1e5+10,P=131;
int n,m;
char str[N];
//p[]是对进制P的预处理，记录了P的不同幂次方
//h[]存放的是该字符串的每一个字母对应的hash值
ULL h[N],p[N];
int 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的幂次方，所以在此提前做预处理
//预处理，这里溢出值相当于取模后的值
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)) printf("Yes\n");
else printf("No\n");
}
return 0;
}tips：
注意上述所给出的一些小技巧，能更好的帮助理解。
而且比如：p[i]=p[i-1]*P;很好的避免了pow(P,i)的繁杂操作
倘若还是不理解就先将公式记下来
