compress words (KMP/字符串哈希，双哈希）

已于 2022-02-15 15:12:36 修改
阅读量1.2k 收藏 3
点赞数 3
分类专栏： 字符串 数据结构 # 哈希表 文章标签： 哈希算法 算法 c++
于 2022-02-15 11:56:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51070956/article/details/122931710
版权
本文探讨了一种字符串连接方法，避免单词间的重复字段，并利用KMP算法求最长相同前后缀。同时，文章详细阐述了双哈希策略，包括如何处理字符串哈希值的计算和比较，以及在不同编程环境下的注意事项。此外，还分析了字符串操作的时间复杂度，提出了优化技巧，如使用s.size()代替strlen()，以及双哈希的实现和滚动数组优化。
摘要由CSDN通过智能技术生成

compress words

在这里插入图片描述
题目链接
这下好了，霍，一打开这篇，目录惊人，一道题这么多问题，显然，某人智商堪忧

连接若干单词，规避单词尾和下一个单词首的重复字段

kmp求最长相同前后缀

交到coedforce上，next数组报错，应该是同名了，保险起见改成nex

 还是对kmp算法的理解不够深刻，成功匹配时j=le,
	不成功，一种是不相等，终究还是主串比完了也没能全部匹配上
	就看最后这个j表示匹配哪儿 
	如果主串最后一个字符也未能与s[0]比较成功，j就会变为-1，继而加一得0 
	想象匹配过程中 
	abcdefgh
		 fgheg 

#include <iostream>
#include <math.h>
using namespace std;
#include <string>
const int N=1e6+10;
string t,s;
int len;//后续输入字符串的长度 
int nex[N];
void getNext(){
	int i=0;
	int j=-1;
	nex[0]=-1;
	while(i<len){
		if(j==-1||s[i]==s[j]){
			i++;
			j++;
			nex[i]=j;
		}
		else j=nex[j];
	}
}
int kmp(int st){
	int i=st,j=0;
	int le=t.size();
	while(i<le){
		while(j!=-1&&t[i]!=s[j])j=nex[j];
		i++;j++;	
	}
//	while(i<le){
//		if(j==-1||t[i]==s[j]){
//			i++;
//			j++;
//		}
//		else j=next[j];
//	}
	return j;
//还是对kmp算法的理解不够深刻，成功匹配时j=le,
//	不成功，一种是不相等，终究还是主串比完了也没能全部匹配上
//	就看最后这个j表示匹配哪儿 
//	如果主串最后一个字符也未能与s[0]比较成功，j就会变为-1，继而加一得0 
//	想象匹配过程中 
//	abcdefgh
//		 fgheg 
}
int main(){
	int n;
	cin>>n;
	cin>>t;
	for(int i=1;i<n;i++){
		cin>>s;
		len=s.size();
		getNext();
		int st;//成型字符串的开始匹配位置 ,不必回回从0开始
		st=t.size()-len; 
		st=max(0,st);
		int pos=kmp(st); 
		t+=s.substr(pos,len-pos+1);
	}
	cout<<t;
	return 0;
}

字符串双哈希

思路：

把第一个单词当作所求字符串t
之后输入一个单词s后便算出这个单词的字符串前缀哈希，
由 于 重 叠 的 长 度 是 m i n ( s t r l e n ( t ) , s t r l e n ( s ) ) , 由于重叠的长度是min(strlen(t),strlen(s)), 由于重叠的长度是min(strlen(t),strlen(s)),
在s中这段长度，分别比较 s的前缀哈希值和
t对应后缀段的哈希值,确定要将s的某段加入t，进一步求出t完整段的哈希值一遍getH取得后缀段的哈希值

WC我没想到这道题耗了我如此之久
问题一堆：

问题一

不断拼接一段字符串 s s s到原有字符串 t t t上，总共长度数据范围是 1 e 6 1e6 1e6,为了求已有长度字符串的哈希值，反复使用 s t r l e n （ t + 1 ） strlen（t+1） strlen（t+1）
n n n的范围是 1 e 5 1e5 1e5，strlen时间复杂度是 O ( n ) O(n) O(n), 外层循环+内部 s t r l e n , 复 杂 度 O ( n 2 ) strlen,复杂度O(n2) strlen,复杂度O(n2)，循环里面还用ｓｔｒｌｅｎ真的是超时到绝望
strlen

	scanf("%s",t+1);
	int st=1;
	for(int j=1;j<n;j++){
		scanf("%s",s+1);
		int len=strlen(t+1);
		int le=strlen(s+1);
		for(int i=st;i<=len;i++){
			int id=getID(t[i]);
			h[i]=(h[i-1]*bas+id)%mod;
		}
		……
		……
		……

strlen所作的仅仅是一个计数器的工作，它从内存的某个位置（可以是字符串开头，中间某个位置，甚至是某个不确定的内存区域）开始扫描，直到碰到第一个字符串结束符’\0’为止，然后返回计数器值(长度不包含’\0’)。

我们用cin>>s和scanf(%s)输入字符串时，会在接受完字符串后在末尾加个’\0’，也就是NULL作为字符串结束符。

所以用strlen函数求解字符串长度的时候，复杂度就是O(n)。如果在循环中用

for (int i = 0; i < strlen(s); ++i)//复杂度O(n2) 那就麻烦了，可能会超时，解决办法：

（1）先把strlen(s)先用变量存储起来，再放入循环中；

（2）或者用s[i] != ‘\0’；

问题二

1、
ll mod[2]={1e9+7,999999998};编译器上运行没问题，交到codeforce上，compile error，理由是1e9+7将算作double类型的浮点数， 1.000000000 ∗ 1 0 7 1.000000000*10^7 1.000000000∗107
ll mod[2]={1000000007,999999998};✔
2、类似的还有，cin>>s+1，报错说是没有重载运算符啥的operator
3、还有之前的next的重名

问题三

双重哈希或者多重哈希，一定要每一种哈希函数之下的哈希值都相等才能判断两字符串相等，是个&&的关系，所以

st=len+1;
int pos=0;
ll H[2]={0,0};
for(int i=1;i<=le&&i<=len;i++){
			int id=getID(s[i]);
			int ok=1;
			for(int k=0;k<2;k++){
			H[k]=(H[k]*bas[k]+id)%mod[k];//s字符串s[1--i]这段哈希值
//	ll temp=((h[k][len]-h[k][len-i]*p[k][i])%mod[k]+mod[k])%mod[k];
			if(H[k]!=getH(len-i+1,len,k))ok=0;
			}
			if(ok)pos=i;//12345
		}

只要在一个哈希函数下的哈希值对应不相等，就不能算作字符串相等

问题四

H[2][N]优化为H[2]嘛，算是个临时变量，专门用来记录输入下一个单词的前缀哈希值，不断输入单词，所以H数组每次都要记得初始化啊，不能在全局变量定义了就完事了（只初始化一次），因为==H[k]=(H[k]*bas[k]+id)%mod[k];==要用到上次的H【k】值，有点像滚动数组的优化
如果不用滚动数组优化，就不用次次初始化啦，
H[k][i]=(H[k][i-1]*bas[k]+id)%mod[k];
耗空间呀

	for(int i=1;i<=le&&i<=len;i++){
			int id=getID(s[i]);
			int ok=1;
			for(int k=0;k<2;k++){
			H[k][i]=(H[k][i-1]*bas[k]+id)%mod[k];//s字符串s[1--i]这段哈希值
//			ll temp=((h[k][len]-h[k][len-i]*p[k][i])%mod[k]+mod[k])%mod[k];
			if(H[k][i]!=getH(len-i+1,len,k))ok=0;
			}
			if(ok)pos=i;//12345
		}

问题五

用字符串hash可以O ( n ) 处理，O ( 1 )比较。因为每个串只会被扫一遍，可以直接暴力，预处理 O ( n ) ，暴力O ( n ) O(n)查找最长相同部分。

由于字符串长达到了 1 0 6 10^6 106
单模hash 已经搞不了，要用更安全的双 hash,取 2 个较大的模数 mod1 和 mod2，以及一个素数 p (p 不用太大，单模的 p 也不用太大，模数一定要大)

ll bas[2]={131,2333333};
ll mod[2]={1000000007,999999998};

1e5可以用 P取131，mod取1<<64，通过unsigned long long来取模的 组合 单哈希，
一旦到了1e6还是老老实实用双哈希甚至三哈希，其实也不是什么难事儿，把p数组，mod数组，H数组，h数组，都变成k维就好，多一个循环for（int j=0;j<k;k++)……就好

建议取以上两种哈希函数的P和mod组合，很强，后面那一组用来单哈希在这题甚至可以AC

问题六

这题大小写字母是当作不相等的，一开始理解反了，白费我写一个
int getID(char ch){//65 97
if(ch>=‘A’&&ch<=‘Z’)ch+=32;
return ch;
}
这样可，但没必要，P进制P取得已经够大了，48——65——97——122，完全可以错开取不同值，直接用s[i]就ok
int getID(char c){
if(c>=‘a’&&c<=‘z’) return c-‘a’;
if(c>=‘0’&&c<=‘9’) return c-‘0’+26;
return c-‘A’+36;
}

问题七

复杂度分析的不好，一开始超时还以为是快速幂和初始化P的幂次的初始化的选择问题
测试证明，这题初始化P幂次的数组p来得比快速幂快
反正 初始化P幂次的数组p 就是O(n)的复杂度，不会造成实质性的超时，用这个

代码

单哈希
2333333
999999998
就连131和unsigned long long的组合也会被卡

#include <iostream>
#include <string.h>
using namespace std;
typedef long long ll;
const int N=1e6+10;
char t[N];
char s[N];
ll bas=2333333;
ll mod=999999998;
ll h[N];
ll H[N];
ll p[N];
void init(){
	p[0]=1;
	for(int i=1;i<N;i++){//N位最高幂次是N-1
		p[i]=(p[i-1]*bas)%mod;
	}
}
ll getH(int l,int r){
	return ((h[r]-h[l-1]*p[r-l+1])%mod+mod)%mod;
}
int main(){
	init();
	int n;
	cin>>n;
	scanf("%s",t+1);
	int len=strlen(t+1);
	int st=1;
	for(int j=1;j<n;j++){
		scanf("%s",s+1);
		int le=strlen(s+1);
		for(int i=st;i<=len;i++){
			h[i]=(h[i-1]*bas+t[i])%mod;
		}
		st=len+1;
		int pos=0;
		for(int i=1;i<=le&&i<=len;i++){
			H[i]=(H[i-1]*bas+s[i])%mod;//s字符串s[1--i]这段哈希值
			if(H[i]==getH(len-i+1,len))pos=i;//12345
		}
		for(int i=pos+1;i<=le;i++){
			t[++len]=s[i];
		}
	}
	printf("%s",t+1);
	return 0;
}

双哈希（So easy，先写个单哈希，再逐一将 m o d − > m o d [ k ] , b a s − > b a s [ k ] , h [ i ] − > h [ k ] [ i ] mod->mod[k],bas->bas[k],h[i]->h[k][i] mod−>mod[k],bas−>bas[k],h[i]−>h[k][i],求哈希值时用个k循环，要注意的就是判断字符串相等时一定要每个哈希函数下的哈希值都满足条件

用二维数组比写两个数组好多了，还可以根据编译器报错的地方补k

#include <iostream>
#include <string.h>
using namespace std;
typedef long long ll;
const int N=1e6+10;
char t[N];
char s[N];
ll bas[2]={131,2333333};
ll mod[2]={1000000007,999999998};
ll h[2][N];
ll H[2][N];
ll p[2][N];
void init(){
	p[0][0]=p[1][0]=1;
	for(int i=1;i<N;i++){//N位最高幂次是N-1
		for(int k=0;k<2;k++)
		p[k][i]=(p[k][i-1]*bas[k])%mod[k];
	}
}
ll getH(int l,int r,int k){
	return ((h[k][r]-h[k][l-1]*p[k][r-l+1])%mod[k]+mod[k])%mod[k];
}
int main(){
	init();
	int n;
	cin>>n;
	scanf("%s",t+1);
	int len=strlen(t+1);
	int st=1;
	for(int j=1;j<n;j++){
		scanf("%s",s+1);
		int le=strlen(s+1);
		for(int i=st;i<=len;i++){
			for(int k=0;k<2;k++)
			h[k][i]=(h[k][i-1]*bas[k]+t[i])%mod[k];
		}
		st=len+1;
		int pos=0;
		for(int i=1;i<=le&&i<=len;i++){
			int ok=1;
			for(int k=0;k<2;k++){
			H[k][i]=(H[k][i-1]*bas[k]+s[i])%mod[k];//s字符串s[1--i]这段哈希值
			if(H[k][i]!=getH(len-i+1,len,k))ok=0;
			}
			if(ok)pos=i;//12345
		}
		for(int i=pos+1;i<=le;i++){
			t[++len]=s[i];
		}
	}
	printf("%s",t+1);
	return 0;
}

最后还可以用滚动数组的思想优化一下空间
H[2][N]–>H[2]

	ll H[2]={0,0};
		for(int i=1;i<=le&&i<=len;i++){
			int ok=1;
			for(int k=0;k<2;k++){
			H[k]=(H[k]*bas[k]+s[i])%mod[k];//s字符串s[1--i]这段哈希值
			if(H[k]!=getH(len-i+1,len,k))ok=0;
			}
			if(ok)pos=i;//12345
		}

反过来求哈希值，搞清楚各位的权值

……cba cba……
<—— ——>
求abc
反过来求反过来字符串的哈希值（高位到低位），和原来一样
h = h ∗ b a s + a n s [ i ] h=h*bas+ans[i] h=h∗bas+ans[i]
正着顺序求反过来字符串的哈希值（低位到高位），
H + = H ∗ w e i g h t — — w e i g h t ( 11 ∗ b a s 1 ∗ b a s ∗ b a s ) H+=H * weight ——weight(1 1*bas 1*bas*bas) H+=H∗weight——weight(11∗bas1∗bas∗bas)
由低位到高位求数值 各位权值为1 1bas 1bas*bas

s . s i z e ( ) 比 s t r l e n ( s ) 快 好 多 s.size()比strlen(s)快好多 s.size()比strlen(s)快好多

在这里插入图片描述

中间是倒着求字符串哈希值，用ans.size()
最顶上是把ans.size()换成strlen(ans)
最底下是开了数组双哈希的情形

#include <iostream>
#include <string.h>
using namespace std;
typedef unsigned long long ull;
const int N=1e6+10;
//ll bas[2]={131,2333333};
//ll mod[2]={1000000007,999999998};

char ans[N];
char s[N];
//string ans,s;
ull bas=2333333;
ull mod=999999998;
int main(){
	int n;
	cin>>n;
	cin>>ans;
	for(int j=1;j<n;j++){
		cin>>s;
		int len=strlen(ans);
		int le=strlen(s);
		ull bass=1;
		int pos=0;
		ull h=0;//一定每次要初始化的呀，只要不是通过数组记录每一段的哈希值
//		而是一个变量记录某一段的哈希值一定要惊醒初始化 
		ull H=0;
		for(int i=1;i<=min(len,le);i++){//枚举长度cdefabc  abcmnjk
			h=(h*bas+ans[len-i])%mod;//求字符串反过来的哈希值 cba
			H=(H+s[i-1]*bass)%mod;
//由于倒过来，由低位到高位求数值 各位权值为1 1*bas 1*bas*bas 
			bass=bass*bas%mod;
			if(H==h)pos=i;//i其实是相等字符的下一个的下标了 
		}
//		ans+=substr(pos);//如果是string ans; ans[len++]是不行的 
		for(int i=pos;i<le;i++){
			ans[len++]=s[i];
		} 
	}
	cout<<ans;
	return 0;
}
Selvaggia
关注
专栏目录
C/C++ 字符串压缩算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-27 7825
Run-Length Encoding (RLE)：将连续重复出现的字符或字符序列用一个计数值和该字符表示。例如，字符串 “AAAABBBCCDAA” 可以被压缩为 “4A3B2C1D2A”。字符串压缩算法是一种用于减少字符串所占用存储空间的技术。其基本思想是将重复出现的字符或字符序列用更短的方式表示，从而减少存储空间的使用。Huffman 编码：根据字符出现的频率构建 Huffman 树，将出现频率高的字符用较短的编码表示，从而减少存储空间的使用。
[codeforces1200E]Compress Words
dxyinme-Zz
09-11 354
time limit per test : 1 second memory limit per test : 256 megabytes 分数：2000，但是我觉得这个题挺神的。 Amugae has a sentence consisting of nnn words. He want to compress this sentence into one word. Amugae doesn’t...
小明的魔法城堡（字符串双哈希）
AC__dream的博客
09-15 322
题目链接：信息学奥赛比赛系统 | 小明的魔法城堡 (qduoj.com) 这道题目是判断每个字符串去掉一个字符后有没有与其相同的字符串出现，显然是要用哈希来处理，需要注意的是一般题目最好用双哈希，这样可以尽可能地降低冲突率，下面来说一下这道题目用哈希该如何处理。 如果两个字符串完全相同，那么他们的哈希值无论在什么进制下都会相同，我们可以先把所有字符串的哈希值都存到map里面，然后我们再检查每一个字符串删掉一个字符后的字符串的哈希值是否在map里面出现过就好了，求每个字符串总的哈希值我在这就不多说了，如果
24.9.8（字符串双哈希）
最新发布
breath_of_yuan的博客
09-09 818
举个栗子，一长为2的链，根节点为a，叶子为b，此时b的深度即dep【b】为2，fa【b】是a，如果输入an，a，将a作为an的儿子，那么fa【a】=an，a的深度变为dep【a】=1，在压缩时，如果写的+1，那么dep【b】=dep【a】+1 =2，就会出错，，所以对深度的处理应为+=dep【fa【x】】思路: 注意读题，题面给了几个关键信息，一是给边形式为a，b且a是b的父亲，代表着不用双边建树，二更为关键，询问的c不会是之前的b，代表着c必定是一棵树的根，因为没当过儿子。补 24牛客多校 四 I。
Compress Words
b24384504986189的博客
08-12 214
E. Compress Words 直接套 KMP 即可（那为什么打 cf 的时候没有想到...），求出后一个单词（word）的前缀数组，然后从前面已得的字符串的末尾 - word. length () 开始查询利用前缀数组进行优化即可 代码: // Created by CAD on 2019/8/12. #include <bits/stdc++.h> using ...
字符串哈希模板（单双哈希）
酒姬民的博客
09-13 2330
字符串哈希模板（单双哈希）
字符串哈希，KMP——Compress Words
行走天涯的豆沙包的博客
04-29 224
传送门 题解： 法一使用字符串哈希，我们很清楚对于父串的后缀哈希值等于匹配串的哈希值的时候就是需要减去的。所以这里父串使用反哈希，子串正向哈希就行了。 #include <bits/stdc++.h> using namespace std; typedef unsigned long long ull; const ull mod=999999998; const ull base=...
POI 上传文件坑解决方案，Caused by: java.lang.NoClassDefFoundError: org/apache/commons/compress/utils/InputStre
热门推荐
m0_48120149的博客
01-13 1万+
Caused by: java.lang.NoClassDefFoundError: org/apache/commons/compress/utils/InputStreamStatistics POI 上传文件坑，找了两个小时终于找到解决方案了 结论：org.apache.commons POI 需要依赖commons 而commons 版本太低，缺失util导致， 解决办法：更换 org.apache.commons 高版本依赖即可 报错信息 java.io.IOException: or
LeetCode 面试题 01.06. 字符串压缩
01-20
字符串压缩题目解题思路图解代码实现实现结果补充 面试题 01.06. 字符串压缩 题目来源：https://leetcode-cn.com/problems/compress-string-lcci 题目 字符串压缩。利用字符重复出现的次数，编写一种方法，实现...
C#自定义字符串压缩和解压缩的方法
09-03
在C#编程中，字符串压缩和解压缩是常见的数据处理任务，特别是在处理大量文本或传输数据时，压缩可以显著减少存储空间和网络带宽。本文将深入探讨如何使用C#自定义字符串压缩和解压缩的方法。 首先，我们可以看到...
E. Compress Words
asmallfish1985的博客
08-12 129
E. Compress Words KMP #include<bits/stdc++.h> using namespace std; int p[1000005]; int len; void getNext(char *s) { int i=0,j=-1; p[0]=-1; int n=strlen(s); for(...
E. Compress Words(KMP)
Foolishman的博客
02-21 646
[E. Compress Words](https://codeforces.com/contest/1200/problem/E) time limit per test1 second memory limit per test256 megabytes inputstandard input outputstandard output Amugae has a sentence consis...
Codeforeces 727 E 字符串双Hash 2017/1/12
I good vegetable a!
01-14 1243
题目链接：见这里 题意：n个长度为k的字符串，首尾相接，按顺时针顺序写在一张CD上，每个字符串只写一次总字符串长度小于1e6。保证每个字符串不同。这样CD上就有了一个环形字符串，长度是n*k。又给出g个长度为k的字符串列表（编号从1到g），按照顺时针打印CD上字符串的编号。保证每个字符串不同。保证这g个字符串长度的和小于2*1e6。 下面代码和思路参考了Wannafly每日一题，顺便学会了Has
Compress Words(前后缀匹配-＞kmp算法)
m0_73674034的博客
03-17 127
kmp模板实操
字符串hash双值hash
qq_45778406的博客
02-21 3214
双值Hash就是用两个不同的mod值来计算Hash，如果两个Hash值都相等才认为是同一个字符串，Hash冲突概率降低了很多，但是常数大，容易被卡。时间上：自然溢出法<单Hash+大质数<双Hash+大质数。 Hash的几个常用公式: Hash递推： Hash[0]=0; Hash[i]=(Hash[i-1]*p+s[i]-‘a’+1)%mod; 区间Hash值： Hash[L…R]=(Hash[R]-Hash[L]*p^(R-L+1)+mod)%mod;这里减法可能会溢出 eg: ha
E. Compress Words（Hash，KMP）
weixin_30782331的博客
08-12 213
E. Compress Words time limit per test 1 second memory limit per test 256 megabytes input standard input output standard output Amugae has a sentence consisting of...
org/apache/commons/compress/utils/InputStreamStatistics 对应的依赖
09-03
`org/apache/commons/compress/utils/InputStreamStatistics` 类通常是由 Apache Commons Compress 库提供的。因此，您需要将以下依赖项添加到您的项目中，以解决这个问题： Maven 项目: ```xml <groupId>org....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值