《算法笔记》学习记录 Part 6 字符串专题

第十二章 字符串专题

12.1 字符串hash进阶

字符串hash是将一个字符串S映射为一个整数，使得该整数可以尽可能唯一地代替字符串S。

使用散列函数，H[i] = ( H[i-1] * 26 + index(str[i])  ) % mod

通过这种方式把字符串转换成范围上能接受的整数，在实践中发现，在int数据范围内，如果把进制数设为为一个10^7级别的素数p（如10000019），同时把mod设置为一个10^9级别的素数（如1000000007），那么冲突的概率回很小

H[i] = ( H[i-1] * p + index(str[i]) ) % mod

问题一：给出N个只有小写字母的字符串，求其中不同的字符串的个数。

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
const int MOD = 1000000007;
const int P = 10000019;
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;
}

问题二：输入两个长度均不超过1000的字符串，求它们的最长公共子串的长度

可以先分别对两个字符串的每个字符串求出hash值（同时记录对应的长度），然后找出两堆子串对应的hash值中相等的那些，便可以找到最大长度，时间复杂度 O（n^2 + m^2 )

#include <iostream>
#include <cstdio>
#include <string>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;
typedef long long LL;
const LL MOD = 100000007;	//模数
const LL P = 10000019;	//P为计算hash值时的进制数
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值，子串长度>,pr2同理
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);
	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+二分解决，时间复杂度为O(nlogn）

#include <iostream>
#include <cstdio>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long LL;
const LL MOD = 100000007;	//模数
const LL P = 10000019;	//P为计算hash值时的进制数
const LL MAXN = 200010;	//MAXN为字符串最长长度
//powP[i]存放p^i%MOD,H1和H2分别存放str1和str2的hash值
LL powP[MAXN],H1[MAXN],H2[MAXN];

//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，在[1,r]里二分回文半径
//寻找最后一个满足条件“hashL == hashR” 的会问半径
//等价于寻找第一个满足条件“hashL ！= hashR”的回文半径，然后减一即可
//isEven当求奇回文时为0，当求偶回文为1
int binarySearch(int l,int r,int len,int i,int isEven){
	while(l<r){
		int mid = (l+r)/2;
		//左半子串hash值H1[H1L...H1R],右半子串hash值H2[H2L...H2R]
		int H1L = i-mid + isEven , H1R=i;
		int H2L = len-1-(i+mid),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;	//返回最大回文半径
}
int main() {
	init();
	string str;
	getline(cin,str);	//计算str的hash数组
	reverse(str.begin(),str.end()); 	//将字符串反转
	calH(H2,str);	//计算rstr的hash数组
	int ans=0;
	//奇回文
	for(int i=0;i<str.length();i++){
		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++){
		int maxLen = min(i+1,(int)str.length()-1-i)+1;
		int k = binarySearch(0,maxLen,str.length(),i,1);
		ans = max(ans,k*2);
	}
	printf("%d\n",ans);
	return 0;
}