【知识点1】字符串hash进阶⭐⭐⭐⭐⭐

知识回顾

字符串hash是将一个字符串S映射为一个整数，使得该整数可以尽可能唯一地代表字符串S。 那么在一定程度上，如果两个字符串转换成的整数相等，就可以认为这两个字符串相同。

注意：H[i]表示从开头到以第i个字符结尾的子串的hash值。因此H[0]需要自行初始化。

改进的字符串hash

引入取模运算

避免冲突

示例

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;

const int MOD = 1000000007;		//即1e9 + 7
const int P = 10000019;			//即1e7 + 19

vector<int> ans;

//字符串hash
long long hashFunc(string str){
	long long H = 0;		//使用long long避免溢出
	for(int i = 0;i<str.length();i++){
		H = ( H * P + str[i] - 'a') % MOD;
	}
	return H; 
}

int main(){
	string str;
	while(getline(cin,str),str != "#"){		//输入str直到#时停止 
		long long id = hashFunc(str);		//将字符串str转换为整数
		ans.push_back(id); 
	}
	
	sort(ans.begin(),ans.end());			//排序
	int count = 0;
	for(int i = 0;i < ans.size();i++){
		if(i == 0 || ans[i] != ans[i - 1]){
			count++;	//统计不同的数的个数 
		}
	}
	cout<<count<<endl;
	return 0; 
} 

字符串子串的hash

推导

括号内部可能小于0的原因是计算H[j]和H[i-1]进行了取模运算，所以可能会有出现小于0的情况。

示例

然后来看一个问题：输入两个长度均不超过1000的字符串，求它们的最长公共子串的长度。例如字符串“ILoveYou”与“YouDontLoveMe”的最长公共子串是“Love”而不是“You”，因此输出4。（注意：子串必须连续）
对这个问题，可以先分别对两个字符串的每个子串求出hash值（同时记录对应的长度），然后找出两堆子串对应的hash值中相等的那些，便可以找到最大长度，时间复杂度为$O(n^2+m^2)$，其中n和m分别为两个字符串的长度。代码如下：

#include<iostream>
#include<cstdio>
#include<string>
#include<vector>
#include<map>
#include<algorithm>

using namespace std;

typedef long long LL;

const LL MOD = 1000000007;		//MOD为计算hash值时的模数，即1e9 + 7 
const LL P = 10000019;			//P为计算hash值时的进制数，即1e7 + 19 
const LL MAXN = 1010;			//MAXN为字符串最长长度

//powP[i]存放P^i%MOD，H1和H2分别存放str1和str2的hash值
LL powP[MAXN],H1[MAXN] = {0},H2[MAXN] = {0};

//pr1存放str1的所有<子串hash值，子串长度>，pre2同理
vector<pair<int,int> > pr1,pr2;

//init函数初始化powP
void init(int len){
	powP[0] = 1;
	for(int i=1;i <= len ;i++){
		powP[i] = (powP[i-1] * P) % MOD;
	}
} 

//calH函数计算字符串str的hash值
void calH(LL H[],string &str){
	H[0] = str[0];			//H[0]单独处理
	for(int i = 1;i < str.length();i++){
		H[i] = (H[i-1] * P + str[i]) % MOD; 
	} 
} 

//calSingleSubH计算H[i...j]
int calSingleSubH(LL H[],int i,int j){
	if(i == 0) return H[j];		//H[0...j]单独处理
	return ((H[j] - H[i - 1] * powP[j - i + 1]) % MOD + MOD) % MOD; 
}

//calSubH计算所有子串的hash值，并将<子串hash值，子串长度>存入pr
void calSubH(LL H[],int len,vector<pair<int,int> >&pr){
	for(int i=0;i<len;i++){
		for(int j=i;j<len;j++){
			int hashValue = calSingleSubH(H,i,j);
			pr.push_back(make_pair(hashValue,j-i+1));
		}
	} 
}

//计算pr1和pr2中相似的hash值，维护最大长度
int getMax(){
	int ans = 0;
	for(int i=0;i<pr1.size();i++){
		for(int j=0;j<pr2.size();j++){
			if(pr1[i].first == pr2[j].first){
				ans = max(ans,pr1[i].second);
			}
		}
	}
	return ans;
}

int main(){
	string str1,str2;
	getline(cin,str1);
	getline(cin,str2);
	init(max(str1.length(),str2.length()));		//初始化powP数组
	calH(H1,str1);	//分别计算str1和str2的hash值
	calH(H2,str2);
	calSubH(H1,str1.length(),pr1);		//分别计算所有H1[i...j]和H2[i...j]
	calSubH(H2,str2.length(),pr2);
	printf("ans = %d\n",getMax());		//输出最大公共子串长度
	return 0; 
} 

最长回文子串——字符串hash+二分 解决方案

在动态规划章节中，我们介绍了最长回文子串的DP解决方案，时间复杂度为$O(n^2)$。接下来讲解使用字符串hash+二分的方法实现最长回文子串，时间复杂度为 $O(nlogn)$。

代码：

#include<iostream>
#include<cstdio>
#include<string>
#include<vector>
#include<map>
#include<algorithm>

using namespace std;

typedef long long LL;

const LL MOD = 1000000007;		//MOD为计算hash值时的模数，即1e9 + 7 
const LL P = 10000019;			//P为计算hash值时的进制数，即1e7 + 19 
const LL MAXN = 200010;			//MAXN为字符串最长长度

//powP[i]存放P^i%MOD，H1和H2分别存放str1和str2的hash值
LL powP[MAXN],H1[MAXN] = {0},H2[MAXN] = {0};

//init函数初始化powP
void init(){
	powP[0] = 1;
	for(int i=1;i < MAXN ;i++){
		powP[i] = (powP[i-1] * P) % MOD;
	}
} 

//calH函数计算字符串str的hash值
void calH(LL H[],string &str){
	H[0] = str[0];			//H[0]单独处理
	for(int i = 1;i < str.length();i++){
		H[i] = (H[i-1] * P + str[i]) % MOD; 
	} 
} 

//calSingleSubH计算H[i...j]
int calSingleSubH(LL H[],int i,int j){
	if(i == 0) return H[j];		//H[0...j]单独处理
	return ((H[j] - H[i - 1] * powP[j - i + 1]) % MOD + MOD) % MOD; 
}

//对称点为i，字符串长为len,在[l,r]里二分回文半径
//寻找最后一个满足条件“hashL == hashR”的回文半径
//等价于寻找第一个满足条件“hashL ！= hashR”的回文半径，然后减1即可
//isEven当求奇回文时为0，当求偶回文时为1
int binarySearch(int l,int r,int len,int i,int isEven){
	while(l < r){	//当出现l == r时结束（因为范围是[l,r]）
		int mid = (l + r) / 2;
		//左半子串hash值H1[H1L...H1R]，右半子串hash值H2[H2L...H2R]
		int H1L = i - mid + isEven;
		int H1R = i;
		int H2L = len-1-(i+mid);
		int H2R = len-1-(i+isEven);
		
		int hashL = calSingleSubH(H1,H1L,H1R);
		int hashR = calSingleSubH(H2,H2L,H2R);
		
		if(hashL != hashR) r = mid;		//hash值不等，说明回文半径<mid
		else l = mid+1;					//hash值相等，说明回文半径>=mid  
	}
	return l-1;		//理解为什么是“l-1” 
} 

int main(){
	init();		//初始化powP 
	string str; 
	getline(cin,str);
	
	calH(H1,str);	//分别计算str的hash值
	
	reverse(str.begin(),str.end());		//将字符串反转 
	calH(H2,str);
	
	int ans = 0;
	
	//奇回文
	for(int i=0;i<str.length();i++){
		//二分上界为分界点i的左右长度的较小值加1
		int maxLen = min(i,(int)str.length()-1-i) + 1;
		int k = binarySearch(0,maxLen,str.length(),i,0);
		ans = max(ans,k*2+1); 
	} 
	 
	//偶回文
	for(int i=0;i<str.length();i++){
		//二分上界为分界点i的左右长度的较小值加1（注意左长为i+1）
		int maxLen = min(i+1,(int)str.length()-1-i) + i;
		int k = binarySearch(0,maxLen,str.length(),i,1);
		ans = max(ans,k*2); 
	}
	printf("%d\n",ans); 
	return 0; 
}