字符串哈希hash

最新推荐文章于 2024-09-12 19:02:20 发布

Rudy1124

最新推荐文章于 2024-09-12 19:02:20 发布

阅读量196

点赞数 1

文章标签：哈希算法算法

本文链接：https://blog.csdn.net/Rudy1124/article/details/131970237

版权

文章介绍了字符串操作的重要性，特别是哈希函数在字符串处理中的作用。哈希思想是将输入映射到小范围，以便比较和存储。文中讨论了哈希函数的性质，如哈希冲突，并提到了多项式Hash方法。文章还举例说明了哈希在字符串匹配、允许失配匹配和其它字符串问题中的应用，并提供了相关代码示例。

摘要由CSDN通过智能技术生成

字符串操作的意义：

其实字符串操作的意义是很浅显的，广泛运用在我们生活当中，所以字符串操作很重要啊喂qwq。

举个栗子：如果百度对于一个人的一次“常搜”推荐需要10s，那么对于全国网友来说，同时上网的人群基数很高，那么如果服务器性能不好的话，怕不是要炸qwq？？？

so字符串算法是很有必要滴！

定义（言归正传）：

我们规定把字符串映射到整数的函数f，而这个整数函数f就被称为hash值。

说人话：哈希的过程，其实可以看作对一个串的单向加密过程

Hash思想：

Hash 的核心思想在于，将输入映射到一个值域较小、可以方便比较的范围。

attention：

1.在哈希表中，值域需要小到能够接受线性的空间与时间复杂度。

2.在字符串哈希中，值域需要小到能够快速比较

3.同时，为了降低哈希冲突率，值域也不能太小。（后面会讲到）

说人话：保证所加的密不能高概率重复

Hash性质：

最重要的性质可以概括为下面两条：

1.在 Hash 函数值不一样的时候，两个字符串一定不一样；

2.在 Hash 函数值一样的时候，两个字符串不一定一样（只能说大概率一样，但我们要它们尽可能不一样）。我们将 Hash 函数值一样但原字符串不一样的现象称为哈希碰撞。

解释：

我们需要关注的是什么？

时间复杂度和 Hash 的准确率。

通常我们采用的是多项式 Hash 的方法，对于一个长度为 l 的字符串 s 来说，我们可以这样定义多项式Hash函数：f(s)= $\sum_{i=1}^{l}s[i]*b^{l-i}(mod M)$ ，例如对于字符串xyz，其哈希值为 $x*b^{2}+y*b^{1}+z*b^{0}$ ，此方法也称为进制哈希。attention:这里 M需要选择一个素数（至少要比最大的字符要大），b 可以任意选择。

说人话：给出一个固定进制base，将一个串的每一个元素看做一个进制位上的数字，所以这个串就可以看做一个base进制的数，那么这个数就是这个串的哈希值；则我们通过比对每个串的的哈希值，即可判断两个串是否相同（qwq）

实现：

参考代码：（效率低下的版本，实际使用时一般不会这么写）

const int M=1e9+7;//较大的质数
const int B=233;//随便一个数
typedef unsigned long long ull;//最好这样写，因为可以避免低效取模
int get_hash(const string& s){//计算hash值
	int res=0;
	for(int i=0;i<s.size();i++){
		res=((ull)res*B+s[i])%M;//hash递推式
	}
	return res;//返回哈希值
}
bool cmp(const string& s,const string& t){
	return get_hash(s)==get_hash(t);//说明两个字符串大概率一样
}

Hash用途：

字符串匹配：

大概操作：求出模式串的哈希值后，求出文本串每个长度为模式串长度的子串的哈希值，分别与模式串的哈希值比较即可。（qwq）

允许k次失配的字符串匹配：

[TJOI2017] DNA - 洛谷题目链接。

这道题无法使用 KMP 解决，但是可以通过哈希 + 二分来解决。

枚举所有可能匹配的子串，假设现在枚举的子串s，通过哈希 + 二分可以快速找到最长的相同长度，找到后再跳过失配的位置，最后判断两给子串的hash值是否相同。（是不是很简单qwq）

接下来的代码来自CZH+++注释写的很详细（因为我懒得写emmmmmm）：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
#define ull unsigned long long 
const int N = 1e5 + 10;
const int b = 131;//base
//自然溢出，没有被卡
int T,ans,n,m;
char s[N],t[N];
ull p[N];
ull f[N],g[N];
ull h(ull *hash,int l,int r){//求子串的hash值
	return (hash[r]-hash[l-1]*p[r-l+1]);
}
int lcp(int x,int y,int r){
	int l = 1;
	while(l<=r){//二分
		int mid = l+r >>1;
		if(h(f,x,x+mid-1)==h(g,y,y+mid-1)) l=mid+1;
		else r = mid-1;
	}
	return l-1;//返回长度
}
bool check(int x){
	int y=1,r=x+m-1,l;//x是s0子串的开头，y是s子串的开头，r是s0子串的结尾
	for(int i=1;i<=3;i++){
		l = lcp(x,y,m-y+1);
		x += l+1;//跳过失配的位置
		y += l+1;
		if(y>m) return 1;
	}
	return h(f,x,r)==h(g,y,m);
}
int main(){
	scanf("%d",&T);
	p[0] = 1;
	for(int i=1;i<=N-10;i++){//预处理
		p[i] = p[i-1]*b;
	}
	while(T--){
		ans = 0;
		scanf("%s%s",s+1,t+1);
		n = strlen(s+1);
		m = strlen(t+1);
		if(n<m){
			puts("0");
			continue;
		}
		f[0] = g[0] = 0;
		for(int i=1;i<=n;i++){
			f[i] = (f[i-1]*b + s[i]);
		}
		for(int i=1;i<=m;i++){
			g[i] = (g[i-1]*b + t[i]);
		}
		for(int i=1;i<=n-m+1;i++){
			if(check(i)) ans++;
		}
		printf("%d\n",ans);
	}
	return 0;
}

多次询问子串哈希：

单次计算一个字符串的哈希值复杂度是 O(n),其中n为串长，与暴力匹配没有区别，如果需要多次询问一个字符串的子串的哈希值，每次重新计算效率非常低下。

so：对整个字符串先预处理出每个前缀的哈希值，将哈希值看成一个b 进制的数对 M取模的结果，这样的话每次就能快速求出子串的哈希了（其实上面已经介绍过了，这就是进制hash，这里在具体讲一讲，主要是我自己不太会。。。qwq）

最长回文子串：

这个问题可以使用 manacher 算法在O(n)时间内解决。

二分答案，判断是否可行时枚举回文中心（对称轴），哈希判断两侧是否相等。需要分别预处理正着和倒着的哈希值。（网上有很多讲解此题的这里推荐一个

最长回文子串的五种求法(暴力、中点扩散、DP、hash+二分、Manacher)_求最长子串的算法_chp的博客的博客-CSDN博客
里面讲的很详细，也有多种解法）好好向被人学学。。。。。emmmmmmm

最长公共子字符串：

最长公共子串_求n个字符串的最长公共子串_卷心菜不卷Iris的博客-CSDN博客目前~~蒟蒻瑟瑟发抖我也没太看懂。%%%~~

确定字符串中不同子字符串的数量：

问题：给定长为n的字符串，仅由小写英文字母组成，查找该字符串中不同子串的数量。

为了解决这个问题，我们遍历了所有长度为l=1,2,3.....n的子串。对于每个长度为l，我们将其 Hash 值乘以相同的b 的幂次方，并存入一个数组中。数组中不同元素的数量等于字符串中长度不同的子串的数量，并此数字将添加到最终答案中。

attention:h[i]做为Hash的前缀字符，并定义h[0]=0;

int count_unique_substrings(string const& s) {
  int n = s.size();

  const int b = 31;
  const int m = 1e9 + 9;
  vector<long long> b_pow(n);
  b_pow[0] = 1;
  for (int i = 1; i < n; i++) b_pow[i] = (b_pow[i - 1] * b) % m;

  vector<long long> h(n + 1, 0);
  for (int i = 0; i < n; i++)
    h[i + 1] = (h[i] + (s[i] - 'a' + 1) * b_pow[i]) % m;

  int cnt = 0;
  for (int l = 1; l <= n; l++) {
    set<long long> hs;
    for (int i = 0; i <= n - l; i++) {
      long long cur_h = (h[i + l] + m - h[i]) % m;
      cur_h = (cur_h * b_pow[n - i - 1]) % m;
      hs.insert(cur_h);
    }
    cnt += hs.size();
  }
  return cnt;
}