学习笔记：哈希表

整数的哈希：

之所以使用哈希，是因为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\le N\le 1e5，-1e9\le x\le 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;
}


 

---

21/5/2，update

哈希可以和许多东西结合在一起考察。
比如，哈希与回文串的结合，哈希与二分的结合，哈希与线段树的结合等。

例题：匹配统计

思路：
因为有多组询问，且没有跟新操作，我们发现可以先离线计算出所有的后缀子串的匹配长度，最后直接回答就好了。
接下来的问题就是如何快速计算出A的某一个后缀子串与B字符串的最大匹配长度。
我们发现这个最大匹配长度是满足二分的性质的，假设A串的子串是从i到n的一段，枚举长度mid，当发现A的i~i + mid - 1的哈希值与B的1-mid的哈希值不相等的时候，令r = mid，否则l = mid。最后让cnt[l]++；
时间复杂度O(nlogn)

#include<cstdio>
#include<cmath>
#include<cstring>
#include<iostream>
#include<map>
#include<stack>
#include<queue>
#include<string>
#include<vector>
#include<algorithm>
#define ll long long
#define ull unsigned long long
#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 sf(n) scanf("%d", &n)
#define endl '\n'
#define cyes cout<<"yes"<<endl
#define debug(x) cout<<"-----"<<x<<endl

using namespace std;

const int N = 2e5 + 5, P = 131;

ull p[N], ha[N], hb[N];

int n, m, q;
char a[N], b[N];

init()
{
	p[0] = 1;
	for(int i = 1; i <= max(n, m); i++)	p[i] = p[i - 1] * P;
	
	for(int i = 1; i <= n; i++)	ha[i] = ha[i - 1] * P + a[i];
	for(int i = 1; i <= m; i++)	hb[i] = hb[i - 1] * P + b[i];
}

ull geta(int l, int r)
{
	return ha[r] - ha[l - 1] * p[r - l + 1];
}

ull getb(int l, int r)
{
	return hb[r] - hb[l - 1] * p[r - l + 1];
}

int cnt[N];

int main()
{
	scanf("%d%d%d", &n, &m, &q);
	scanf("%s%s", a + 1, b + 1);
	
	init();
	
	for(int i = 1; i <= n; i++)
	{
		int l = -1, r = min(m, n - i + 1) + 1;
		while(l + 1 != r)
		{
			int mid = l + r >> 1;
			if(geta(i, i + mid - 1) == getb(1, mid))	l = mid;
			else	r = mid;
		}
		cnt[l]++;
	}
	
	while(q--)
	{
		int x; scanf("%d", &x);
		printf("%d\n", cnt[x]);
	}
	
	return 0;
}

---

struct node
{
	int head[N], ne[N], idx;
	ull e[N];
	
	void init()
	{
		idx = 0;
		memset(head, 0, sizeof head);
	}
	
	void insert(ull x)
	{
		int k = (x % N + N) % N;
		e[++idx] = x; ne[idx] = head[k]; head[k] = idx;
	}
	bool find(ull x)
	{
		int k = (x % N + N) % N;
		for(int i = head[k]; i; i = ne[i])
			if(e[i] == x)	return true;
		return false;
	}
} _set;