【模板】后缀数组SA

最新推荐文章于 2024-07-24 11:25:06 发布
最新推荐文章于 2024-07-24 11:25:06 发布
阅读量227 收藏
点赞数
原文链接：http://www.cnblogs.com/zxyoi/p/10047084.html
版权

参考题目：UOJ35

解析：

这次贴的代码有点多，除了最裸的暴力，基本上能够想到的其他各种复杂度能够过和不能过的我都去写了一遍。

但是解析可能要不知道什么时候更了。。。

之后会把后缀数组所有用途和性质都更新过来的。

代码：

哈希二分+快速排序(复杂度O(nlog⁡2n)O(n\log^2n)O(nlog2n))：

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define re register
#define gc getchar
#define pc putchar
#define cs const

cs int N=100005;
cs unsigned ll p=3379,mod=773577411;
unsigned ll Pow[N];

struct Hash_Array{
	unsigned ll Hash[N];
	Hash_Array(){Pow[0]=1;for(int re i=1;i<N;++i)Pow[i]=Pow[i-1]*p%mod;}
	inline void init(char *cs s,cs int &len){
		Hash[0]=0;for(int re i=1;i<=len;++i)Hash[i]=(Hash[i-1]*p%mod+s[i])%mod;
	}
	inline unsigned ll substr(int l,int r){
		return (Hash[r]-Hash[l-1]*Pow[r-l+1]%mod+mod)%mod;
	}
};

namespace SA{
	Hash_Array Hash;
	int sa[N],rk[N],ht[N],len;
	char s[N];
	inline bool rk_cmp(cs int &i,cs int &j);
	inline void init();
};

inline bool SA::rk_cmp(cs int &i,cs int &j){
	int l=0,r=len-max(i,j)+1;
	while(l<r){
		int mid=(l+r)>>1;
		if(Hash.substr(i,i+mid)==Hash.substr(j,j+mid))l=mid+1;
		else r=mid;
	}
	return s[i+l]<s[j+l];
}

inline void SA::init(){
	Hash.init(s,len);
	for(int re i=1;i<=len;++i)sa[i]=i;
	sort(sa+1,sa+len+1,rk_cmp);
	for(int re i=1;i<=len;++i)rk[sa[i]]=i;
	for(int re i=1,k=0,j;i<=len;ht[rk[i++]]=k)
	for(k?--k:0,j=sa[rk[i]-1];s[i+k]==s[j+k];++k);
}

signed main(){
	scanf("%s",SA::s+1);
	SA::len=strlen(SA::s+1);
	SA::s[SA::len+1]='\0';
	SA::init();
	for(int re i=1;i<=SA::len;++i)printf("%d ",SA::sa[i]);pc('\n');
	for(int re i=2;i<=SA::len;++i)printf("%d ",SA::ht[i]);pc('\n');
	return 0;
}

倍增+快排(复杂度O(nlog⁡2n)O(n\log^2n)O(nlog2n))：

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define re register
#define gc getchar
#define pc putchar
#define cs const

cs int N=100005;

namespace SA{
	char s[N<<1],t[N];
	int rk[N<<1];
	int sa[N],ht[N],len;
	int now;
	inline bool rk_cmp(cs int &i,cs int &j);
	inline bool first_sort(cs int &i,cs int &j);
	inline void init();
}

inline bool SA::rk_cmp(cs int &i,cs int &j){
	if(rk[i]^rk[j])return rk[i]<rk[j];
	return rk[i+(1<<(now-1))]<rk[j+(1<<(now-1))];
}

int tmp[N];
inline void SA::init(){
	for(int re i=1;i<=len;++i)sa[i]=i,t[i]=s[i];
	sort(t+1,t+len+1);
	int h=unique(t+1,t+len+1)-t-1;
	for(int re i=1;i<=len;++i)rk[i]=lower_bound(t+1,t+h+1,s[i])-t;
	for(now=1;(1<<(now-1))<=len;++now){
		sort(sa+1,sa+len+1,rk_cmp);
		re int cnt=0;
		for(int re i=1;i<=len;++i){
			if(rk_cmp(sa[i],sa[i-1])||rk_cmp(sa[i-1],sa[i]))++cnt;
			tmp[sa[i]]=cnt;
		}
		for(int re i=1;i<=len;++i)rk[i]=tmp[i];
		if(cnt==len)break;
	}
	for(int re i=1,k=0,j;i<=len;ht[rk[i++]]=k)
	for(k?--k:0,j=sa[rk[i]-1];s[i+k]==s[j+k];++k);
}

signed main(){
	scanf("%s",SA::s+1);
	SA::len=strlen(SA::s+1);
	SA::s[SA::len+1]='\0';
	SA::init();
	for(int re i=1;i<=SA::len;++i)printf("%d ",SA::sa[i]);pc('\n');
	for(int re i=2;i<=SA::len;++i)printf("%d ",SA::ht[i]);pc('\n');
	return 0;
}

倍增+计数排序(复杂度O(nlog⁡n)O(n\log n)O(nlogn))：

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define re register
#define gc getchar
#define pc putchar
#define cs const

cs int N=100005;

namespace SA{
	char s[N];
	int sa[N],rk[N],ht[N];
	int bin[N],len;
	inline void radix_sort(int *cs x,int *cs y,int m,int n);
	inline void init();
}

inline void SA::radix_sort(int *cs x,int *cs y,int m,int n){
	memset(bin+1,0,sizeof(int)*(m));
	for(int re i=1;i<=n;++i)++bin[x[i]];
	for(int re i=1;i<=m;++i)bin[i]+=bin[i-1];
	for(int re i=n;i;--i)sa[bin[x[y[i]]]--]=y[i];
}

inline void SA::init(){
	int *x=rk,*y=ht;
	for(int re i=1;i<=len;++i)x[i]=s[i],y[i]=i;
	int n=len,m=128;
	radix_sort(x,y,m,n);
	for(int re i=1,cnt=0;i<=n&&cnt<n;i<<=1){
		cnt=0;
		for(int re j=n-i+1;j<=n;++j)y[++cnt]=j;
		for(int re j=1;j<=n;++j)if(sa[j]>i)y[++cnt]=sa[j]-i;
		radix_sort(x,y,m,n);
		swap(x,y);
		x[sa[1]]=1;cnt=1;
		for(int re j=2;j<=n;++j)x[sa[j]]=((y[sa[j]]==y[sa[j-1]])&&(y[sa[j]+i]==y[sa[j-1]+i])?cnt:++cnt);
		m=cnt;
	}
	for(int re i=1;i<=n;++i)rk[sa[i]]=i;
	for(int re i=1,k=0,j;i<=len;ht[rk[i++]]=k)
	for(k?--k:0,j=sa[rk[i]-1];s[i+k]==s[j+k];++k);
}

signed main(){
	scanf("%s",SA::s+1);
	SA::len=strlen(SA::s+1);
	SA::s[SA::len+1]='\0';
	SA::init();
	for(int re i=1;i<=SA::len;++i)printf("%d ",SA::sa[i]);pc('\n');
	for(int re i=2;i<=SA::len;++i)printf("%d ",SA::ht[i]);pc('\n');
	return 0;
}

DC3(复杂度O(n)O(n)O(n)，常数较大)：

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define re register
#define gc gechar
#define pc putchar
#define cs const

cs int N=100005;
namespace SA{
	char s[N];
	int sa[N*3],rk[N],ht[N],len;
	int v[N*3],bin[N*3],wa[N*3],wb[N*3];
	int a[N*3];
	inline bool cmp_0(int *cs s,int a,int b);
	inline bool cmp_12(int k,int *cs s,int a,int b);
	inline void radix_sort(int *cs s,int *cs a,int *cs b,int n,int m);
	inline void dc3(int *cs s,int *cs sa,int n,int m);
	inline void init();
}

inline bool SA::cmp_0(int *cs s,int a,int b){
	return s[a]==s[b]&&s[a+1]==s[b+1]&&s[a+2]==s[b+2];
}

inline bool SA::cmp_12(int k,int *cs s,int a,int b){
	return s[a]<s[b]||s[a]==s[b]&&(k==2?cmp_12(1,s,a+1,b+1):v[a+1]<v[b+1]);
}

inline void SA::radix_sort(int *cs s,int *cs a,int *cs b,int n,int m){
	memset(bin,0,sizeof(int)*m);
	for(int re i=0;i<n;++i)++bin[s[a[i]]];
	for(int re i=1;i<m;++i)bin[i]+=bin[i-1];
	for(int re i=n-1;~i;--i)b[--bin[s[a[i]]]]=a[i];
}

inline void SA::dc3(int *cs s,int *cs sa,int n,int m){
	#define F(x) ((x)/3+((x)%3==1?0:tb))
	#define G(x) ((x)<tb?(x)*3+1:((x)-tb)*3+2)
	
	int *sn=s+n,*san=sa+n,ta=0,tb=(n+1)/3,tbc=0,cnt=0;
	s[n]=s[n+1]=0;
	for(int re i=0;i<n;++i)if(i%3!=0)wa[tbc++]=i;
	radix_sort(s+2,wa,wb,tbc,m);
	radix_sort(s+1,wb,wa,tbc,m);
	radix_sort(s,wa,wb,tbc,m);
	
	cnt=1,sn[F(wb[0])]=0;
	for(int re i=1;i<tbc;++i)
	sn[F(wb[i])]=cmp_0(s,wb[i-1],wb[i])?cnt-1:cnt++;
	if(cnt<tbc)dc3(sn,san,tbc,cnt);
	else for(int re i=0;i<tbc;++i)san[sn[i]]=i;
	for(int re i=0;i<tbc;++i)if(san[i]<tb)wb[ta++]=san[i]*3;
	if(n%3==1)wb[ta++]=n-1;
	radix_sort(s,wb,wa,ta,m);
	for(int re i=0;i<tbc;++i)v[wb[i]=G(san[i])]=i;
	re int i=0,j=0;
	for(cnt=0;i<ta&&j<tbc;++cnt)
	sa[cnt]=cmp_12(wb[j]%3,s,wa[i],wb[j])?wa[i++]:wb[j++];
	while(i<ta)sa[cnt++]=wa[i++];
	while(j<tbc)sa[cnt++]=wb[j++];
	
	#undef F
	#undef G 
}

inline void SA::init(){
	for(int re i=1;i<=len;++i)a[i]=s[i];
	a[len+1]=0;
	dc3(a+1,sa,len+1,128);
	for(int re i=1;i<=len;++i)rk[++sa[i]]=i;
	for(int re i=1,k=0,j=0;i<len;ht[rk[i++]]=k)
	for(k?--k:0,j=sa[rk[i]-1];s[i+k]==s[j+k];++k);
}

signed main(){
	scanf("%s",SA::s+1);
	SA::len=strlen(SA::s+1);
	SA::init();
	for(int re i=1;i<=SA::len;++i)printf("%d ",SA::sa[i]);pc('\n');
	for(int re i=2;i<=SA::len;++i)printf("%d ",SA::ht[i]);pc('\n');
	return 0;
}

基于诱导排序的SA-IS(复杂度O(n)O(n)O(n)，常数较小)：

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define re register
#define gc getchar
#define pc putchar
#define cs const

cs int N=100005; 
namespace SA{
	char s[N];
	int sa[N],ht[N],rk[N],a[N],len;
	int wa[N],wb[N];
	bool t[N<<1];
	inline bool islms(int i,bool *cs t);
	inline void induced_sort(int *cs s,int *cs sa,int len,int siz,int sigma,bool *cs t,int *cs b,int *cs cb,int *cs p);
	inline void sais(int *cs s,int *cs sa,int len,bool *cs t,int *cs b,int *cs b1,int sigma);
	inline void init();
}

inline bool SA::islms(int i,bool *cs t){
	return i>0&&t[i]&&!t[i-1];
}

inline void SA::induced_sort(int *cs s,int *cs sa,int len,int siz,int sigma,bool *cs t,int *cs b,int *cs cb,int *cs p){
	memset(b,0,sizeof(int)*sigma);
	memset(sa,-1,sizeof(int)*len);
	for(int re i=0;i<len;++i)++b[s[i]];
	cb[0]=b[0];
	for(int re i=1;i<sigma;++i)cb[i]=cb[i-1]+b[i];
	for(int re i=siz-1;~i;--i)sa[--cb[s[p[i]]]]=p[i];
	for(int re i=1;i<sigma;++i)cb[i]=cb[i-1]+b[i-1];
	for(int re i=0;i<len;++i)if(sa[i]>0&&!t[sa[i]-1])sa[cb[s[sa[i]-1]]++]=sa[i]-1;
	cb[0]=b[0];
	for(int re i=1;i<sigma;++i)cb[i]=cb[i-1]+b[i];
	for(int re i=len-1;~i;--i)if(sa[i]>0&&t[sa[i]-1])sa[--cb[s[sa[i]-1]]]=sa[i]-1;
}

inline void SA::sais(int *cs s,int *cs sa,int len,bool *cs t,int *cs b,int *cs b1,int sigma){
	int *cb=b+sigma,siz=0,cnt=0,p=-1;
	t[len-1]=1;
	for(int re i=len-2;i>=0;--i)t[i]=s[i]==s[i+1]?(t[i+1]):(s[i]<s[i+1]);
//	for(int re i=len-2;~i;--i)t[i]=s[i]<s[i+1]||(s[i]==s[i+1]&&t[i+1]);
	for(int re i=1;i<len;++i)if(t[i]&&!t[i-1])b1[siz++]=i;
	induced_sort(s,sa,len,siz,sigma,t,b,cb,b1);
	for(int re i=siz=0;i<len;++i)if(islms(sa[i],t))sa[siz++]=sa[i];
	for(int re i=siz;i<len;++i)sa[i]=-1;
	for(int re i=0;i<siz;++i){
		re int x=sa[i];
		for(int re j=0;j<len;++j){
			if(p==-1||s[x+j]!=s[p+j]||t[x+j]!=t[p+j]){
				++cnt;
				p=x;
				break;
			}
			else if(j>0&&(islms(x+j,t)||islms(p+j,t)))break;
		}
		sa[siz+(x>>=1)]=cnt-1;
	}
	for(int re i=len-1,j=len-1;i>=siz;--i)if(sa[i]>=0)sa[j--]=sa[i];
	int *s1=sa+len-siz,*b2=b1+siz;
	if(cnt<siz)sais(s1,sa,siz,t+len,b,b1+siz,cnt);
	else for(int re i=0;i<siz;++i)sa[s1[i]]=i;
	for(int re i=0;i<siz;++i)b2[i]=b1[sa[i]];
	induced_sort(s,sa,len,siz,sigma,t,b,cb,b2);
}

inline void SA::init(){
	for(int re i=1;i<=len;++i)a[i]=s[i];
	sais(a+1,sa,len+1,t,wa,wb,128);
	rk[0]=0;sa[0]=len+1;
	for(int re i=1;i<=len;++i)rk[++sa[i]]=i;
	for(int re i=1,k=0,j=0;i<len;ht[rk[i++]]=k)
	for(k?--k:0,j=sa[rk[i]-1];s[i+k]==s[j+k];++k);
}

signed main(){
	scanf("%s",SA::s+1);
	SA::len=strlen(SA::s+1);
	SA::s[SA::len+1]='\0';
	SA::init();
	for(int re i=1;i<=SA::len;++i)printf("%d ",SA::sa[i]);pc('\n');
	for(int re i=2;i<=SA::len;++i)printf("%d ",SA::ht[i]);pc('\n');
	return 0;
}

转载于:https://www.cnblogs.com/zxyoi/p/10047084.html

anlongyi8087
关注
后缀数组 SA
EricQian的博客
03-25 486
后缀数组 SA 后缀树组(SA，suffix array)，用于处理字符串子串形成的结构。 处理子串的结构主要方式有：后缀数组 SA，后缀自动机 SAM，后缀树 ST。 后缀树和后缀自动机暂时决定咕咕咕，以后学习可以参考ix35 的字符串复习。 含义与实现 后缀 我们定义长度为 \(n\) 的字符串 \(s\) 编号为 \(l\) 的后缀为 \(s\) 在 \([l,s]\) 上的字串，记 \(...
后缀数组SA-IS模板
Freopen的博客
05-11 877
SA-IS
后缀数组SA
niiick
11-30 417
后缀数组一般有两种求法 倍增法O(nlogn)O(nlogn)O(nlogn) 和 DC3算法O(n)O(n)O(n) DC3法编程复杂度极高，空间开销也大，所以这里只讲一下倍增法，其实是蒟蒻并不会DC3 学习后缀数组前 你需要对基数排序有一定的了解 了解了基数排序之后我们从下面的问题引入后缀数组 Q：读入一个长度为 n 的字符串，把这个字符串的所有非空后缀按字典序从小到大排序 比如下图这样 ...
SA后缀数组详解与运用
lcy19260817的博客
05-01 838
SA后缀数组1、后缀数组作用2、后缀数组的构造3、 SA算法的用途4、例题：poj 3261 : Milk Patterns5、后记 1、后缀数组作用 主要用于解决最长公共前缀（lcp）问题，大多数时候此类问题都可以用sam（后缀自动机）来解决。不过应为sa算法相对更加优秀的时空复杂度，在大数据集上可以防止TMLE。 2、后缀数组的构造 首先声明几个变量。 1、Str ：需要处理的字符串(长度...
SA后缀数组总结
chiyankuan的博客
07-14 790
SA后缀数组用于字符串。首先把每一个位置对应的后缀字符串按字典序从小到大排序，然后设sa[i]表示排名为i的后缀串在原串中对应的位置，rank[i]表示原串中位置i对应的后缀的排名为i。接下来讲讲怎样求sa。这里主要运用了倍增的思想。设S[i,k]表示从i开始长度为k的字符串在所有长度为k的字符串中的排名，一开始我们先求出S[i,1]。接下来我们考虑利用S[i,1]来求S[i.2]。这要用到一条性...
后缀数组模板+LCP小证明
bjfu170203101的博客
05-03 356
复习了一遍后缀数组： https://www.cnblogs.com/victorique/p/8480093.html#autoid-1-3-2 关于LCP的性质，之前理解的是错的，看了这篇blog重新证明了下。 另外： LCP(i,j)其实就是LCP(i,i+1,i+2……，j)即连续L个后缀的LCP #include<cstdio> #include<cstri...
后缀数组模板与计算height数组
后缀数组Sa[1...n]是对一个字符串的所有后缀按字典序排序后的数组。例如，对于字符串"abcba"，其后缀数组为["a", "ab", "abc", "abca", "abcba"]。这里的索引从1开始，而不是通常的0，这是因为0通常被保留用来表示空...
SA 后缀数组
小蒟蒻yyb的博客
01-23 338
首先一定要确定SASA是个什么东西 SA[i]SA[i]表示的是排名为ii的后缀是哪一个 至于后缀ii的排名是多少，那个是rank[i]rank[i] 当然啦 最最最难懂的就是基数排序 要是不用基数排序，每次对于一个二元组直接sortsort一下 这样的复杂度是O(nlog2)O(nlog^2) 对于二元组的基数排序应该是这样做的： 首先把所有元素按照最后一维丢到依次对应的桶里
后缀数组（SA）学习小记
Never give in.
05-13 820
关于SASA这其实并不是一个特别高深的算法，但是有的性质需要自己多推一下，慢慢理解SASA可以在O（NlogN）O（N logN）的复杂度内完成对一个字符串完成后缀的排序，并且可以在O（N）的复杂度内求出排名相邻的两个后缀的最长公共前缀（LCPLCP），非常优秀的解决很多字符串问题。进入正题如果把每个后缀求出来，用快排之类的排序排是需要O（N2logN）O（N^2 log N）的复杂度的（因为还要一
超级简单的后缀数组（SA）！！
WerChange的OI博客
01-14 1049
省流：最详细的博客！一步一步带你分析国集选手的代码！！
【学习笔记】后缀数组SA
七代目鸽影
11-23 390
比较详细的后缀数组介绍。
后缀数组(SA)最通俗易懂的学习笔记
最新发布
2301_79974919的博客
07-24 1170
循环内先对sa进行第二关键字的排序，w同时也是第二关键字相对第一关键字的距离，若原后缀为后缀i，那么其第二关键字就是rk中i+w的位置，此处使用id数组先复制了原来的sa数组，故id[i]+w就相当于每个后缀的第二关键字。那么该前缀和数组中，就记录着从小到大的元素对应的下标所对应的第一次出现的元素的排名，重新遍历原集合中的每一个元素，其在前缀和数组中对应的下标所对应的值就是该元素的排名，排名后需要将前缀和数组中该值减1，若再次出现值相同的另一个元素则赋予它不同的排名以区分相同值的元素。
HDU.6294.SA-IS后缀数组（思维）
红鲤鱼与绿鲤鱼与驴
06-07 636
小Q最近阅读了SA-IS算法在线性时间内构造后缀数组的相关论文，面对任何字符串题，都可以想出线性时间的算法。 小T在经历过二分图匹配事件后，再也不相信小Q所说的话。面对小Q，小T又给出了一道字符串题： 给定一个长度为nn的小写字符串S[1..n]S[1..n]，设sufisufi表示以ii 为开始的后缀，即S[i..n]S[i..n]。 记|X||X|为字符串XX的长度，对于两个字符串XX和YY，...
SA后缀数组模板
代码中转站
12-16 401
下标都是从1开始的 计数排序 const int N=100010; #define MS(x,y) memset(x,y,sizeof(x)) int sa[N],rnk[N],height[N],tax[N],tp[N],n,m,k; char str[N]; void rsort() { for(int i=0;i<=m;i++) tax[i]=0; for(int i=
后缀数组(SA)总结
01-21 266
后缀数组(SA)总结 这个东西鸽了好久了，今天补一下 概念 后缀数组\(SA\)是什么东西？ 它是记录一个字符串每个后缀的字典序的数组 \(sa[i]\):表示排名为\(i\)的后缀是哪一个。 \(rnk[i]\):可以理解为\(SA\)数组的逆，记录后缀\(i\)的排名是多少，\(rnk[SA[i]]=i\)。 \(lcp[i]\):别人一般叫\(height\)，表示后缀\(SA[i...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值