整数的哈希：
之所以使用哈希，是因为x的范围非常大，但个数有限，所以可以用一个比较小的数字来代表它，和离散化有点像，但是离散化是有序的哈希（要求按顺序来，即相对的大小关系不能混淆，我原来比你大，哈希之后的值也要比你大）
整数的哈希一般可以直接对一个数取模（模上的这个数一般取一个质数，可以减少冲突的可能，我也不知道为什么），将得到的值作为它的哈希值，但很有可能会出现冲突的情况（即a与b的哈希值相同），处理冲突的方法有两种：1、拉链法 2、开发寻址法
————————————————————
拉链法：
对于映射到的每一个点，都在该点处拉一条链，把能映射到该点的值用链串起来（即相当于一单链表）
————————————————————
开放寻址法：
将一个哈希表开到实际数量的2~3倍，映射一个值时，如果该哈希值已经被占用了，则走向下一个，直到出现了空位或者找到了自己
————————————————————
直接看题：
维护一个集合，支持如下几种操作：
“I x”，插入一个数x；
“Q x”，询问数x是否在集合中出现过；
现在要进行N次操作，对于每个询问操作输出对应的结果。
输入格式
第一行包含整数N，表示操作数量。
接下来N行，每行包含一个操作指令，操作指令为”I x”，”Q x”中的一种。
输出格式
对于每个询问指令“Q x”，输出一个询问结果，如果x在集合中出现过，则输出“Yes”，否则输出“No”。每个结果占一行。
数据范围
1≤N≤1e5，−1e9≤x≤1e9
拉链法：
const int N = 100003;
int h[N],e[N],ne[N],idx;
void insert(int x)
{
int k=(x%N+N)%N; //防止出现负数 ,k是哈希值
e[idx]=x; ne[idx]=h[k]; h[k]=idx++; //和单链表的插入一样
}
bool find(int x) //查询 x是否存在
{
int k=(x%N+N)%N; //得到 x的哈希值
for(int i=h[k];~i;i=ne[i]) //从表头遍历，看是否存在x
if(e[i]==x) return true;
return false;
}
int main()
{
memset(h,-1,sizeof(h)); //类似单链表，初始时每个点上都没有值，用-1表示指向空
int n; cin>>n;
char op; int x;
while(n--)
{
cin>>op>>x;
if(op=='I') insert(x);
else
{
if(find(x)) puts("Yes");
else puts("No");
}
}
return 0;
}
开放寻址法：
const int N = 200003,null=0x3f3f3f3f;
int h[N];
// 开放寻址法 ，使用该方法的话hash数组一定要开到实际个数的2~3倍
int find(int x)
{
int t=(x%N+N)%N; //防止出现负数
while(h[t]!=null&&h[t]!=x) //直到出现空位或者找到了自己
{
t++;
if(t==N) t=0;//如果找到了最后一个，要从0开始找
}
return t;
}
int main()
{
memset(h,0x3f,sizeof(h)); // 用一个大数表示该点为空
int n; cin>>n;
char op; int x;
while(n--)
{
cin>>op>>x;
if(op=='I') h[find(x)]=x;
else
{
if(h[find(x)]==null) puts("No");
else puts("Yes");
}
}
return 0;
}
————————————————————
字符串哈希：
字符串的哈希方法名为 字符串前缀哈希法
该方法是 对于一个字符串预处理出它所有前缀串的哈希
（长度为n的字符串，h[1]表示前1个字符的哈希值，h[2]表示前2个字符的哈希值…h[i]表示前i个字符的哈希值）
哈希方法是把字符串看作是一个P进制的数，该串的哈希值就是将这个P进制数转化为10进制数的值，由于这个数可能非常大，然后在模上一个数mod
要注意的地方：
1、不能把某一个字符映射成0
2、对于整数会出现冲突的情况，字符串同样有可能，但在这里，我假设人品足够好（字符串出现冲突的可能非常小），不考虑会出现冲突
3、这个P进制中的P一般取131或13331，而这个取模的数取2^64，根据玄学<(￣ˇ￣)/，这样会降低出现冲突的概率（99.99%）
小技巧：
对2^64 取模得到的数的范围是(0~2的64次方-1），就是unsigned long long 的范围，我们可以吧h数组定义成ull类型的变量，这样如果数大于这个范围，系统会自动帮我们取模
接下来就是使用该前缀哈希配上P进制的好处：
利用前缀哈希可以算出来任意一个子串的哈希（n不nb）
比如说对于一个字符串，预处理出来它的所以前缀哈希后，你想求从l到r这一段子串的哈希值可以直接这样求：h[r]-h[l-1]*p^(r-l+1)
类比一下10进制就明白了：
比如说对于 123456,求从4到6这一段
那么 456=123456-123 *10^3
直接看题：
AcWing 841. 字符串哈希
给定一个长度为n的字符串，再给定m个询问，每个询问包含四个整数l1,r1,l2,r2，请你判断[l1,r1]和[l2,r2]这两个区间所包含的字符串子串是否完全相同。
字符串中只包含大小写英文字母和数字。
输入格式
第一行包含整数n和m，表示字符串长度和询问次数。
第二行包含一个长度为n的字符串，字符串中只包含大小写英文字母和数字。
接下来m行，每行包含四个整数l1,r1,l2,r2，表示一次询问所涉及的两个区间。
注意，字符串的位置从1开始编号。
输出格式
对于每个询问输出一个结果，如果两个字符串子串完全相同则输出“Yes”，否则输出“No”。每个结果占一行。
数据范围：1≤n,m≤1e5
#include<cstdio>
#include<cmath>
#include<ctime>
#include<cstring>
#include<iostream>
#include<map>
#include<set>
#include<stack>
#include<queue>
#include<string>
#include<vector>
#define ll long long
#define ull unsigned long long
#define up_b upper_bound
#define low_b lower_bound
#define m_p make_pair
#define mem(a) memset(a,0,sizeof(a))
#define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define inf 0x3f3f3f3f
#define endl "\n"
#include<algorithm>
using namespace std;
inline ll read()
{
ll x=0,f=1; char ch=getchar();
while(ch<'0'||ch>'9') {
if(ch=='-') f=-1; ch=getchar(); }
while('0'<=ch&&ch<='9') x=x*10+ch-'0', ch=getchar();
return f*x;
}
const int N = 1e5+1;
const int P = 131; //P进制
char str[N];
ull h[N],p[N]; //p数组代表的是p的次方数 p[i]存的是p的i次方
ull get(int l,int r) //求子串[l,r]这一段的哈希值
{
return h[r]-h[l-1]*p[r-l+1];
}
int main()
{
int n,m; cin>>n>>m;
p[0]=1; //p的0次方是1 ，预处理出来所有的p
for(int i=1;i<=n;i++) p[i]=p[i-1]*P;
cin>>str+1; //从下标为1开始存
for(int i=1;i<=n;i++) //求前缀哈希
h[i]=h[i-1]*P+str[i]; //把字母当数字
while(m--)
{
int l1,r1,l2,r2;
cin>>l1>>r1>>l2>>r2;
if(get(l1,r1)==get(l2,r2)) //如果[l1,r1]和[l2,r2]的哈希值相等我们就认为这两段相等
puts("Yes");
else
puts("No");
}
return 0;
}