整数的哈希:
之所以使用哈希,是因为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;
}