后缀数组SA学习笔记

什么是后缀数组

后缀数组\(sa[i]\)表示字符串中字典序排名为\(i\)的后缀位置

\(rk[i]\)表示字符串中第\(i\)个后缀的字典序排名

举个例子:

ababa
     a b a b a
rk:3 5 2 4 1
sa: 5(a) 3(aba) 1(ababa) 4(ba) 2(baba)

那么就有\(sa[rk[i]]=rk[sa[i]]=i\)

后缀数组的求法

二周目

倍增法

看一会儿还是比较好记的

但没有理解每句话是在干什么的话以后再写就会没有思路

因此这里简述一下基本过程和一些关键细节

之后使用后缀\(i\)表示位置为\(i\)的后缀,第\(i\)个后缀表示排名为\(i\)的后缀,特此说明

倍增法的基本过程:

首先将所有后缀的第一个字符拿出来做一次排序,并记录其排名,字母相同的排名相同

第二步,将所有后缀的第一个字母和第二个字母拿出来做排序;

我们知道后缀\(i\)的第二个字母的排名就是后缀\(i+1\)的排名,后缀\(n\)没有第二个字母,因此其排名为\(0\)

此时对于\((rk[i],rk[i+1])\)的二元组进行第二次排序,并重新记录其排名

之后求出包括前四个字母\((rk[i],rk[i+2])\)的排名,包括前\(2p\)个字母\((rk[i],rk[i+p])\)的排名...直到\(p\ge n\)为止。

如果直接按照上面的方法模拟,复杂度将是\(O(nlog^2n)\)的

关键细节:基数排序

其实直接模拟用快排求后缀数组思想比较简单

但是基数排序求后缀数组代码简单并且复杂度为\(O(nlogn)\)较为优秀

所以现在一般使用的算法都是基数排序。

我们的基数排序到底是个什么东西呢?

假设我们现在要对一些二元组\((a,b)\)进行排序

设\(x\)表示每个元素对应的a离散之后的权值

\(y\)表示将每个元素按照b排序后的元素编号,\(y\)数组为一个\(1-n\)的排列

\(z\)表示将每个元素按照(a,b)排序后的编号,

注意由于\(y\)数组的存在,求出的\(z\)的排名一定是互不相同的

\(t\)表示桶数组

则代码如下:

int n;
int x[N],y[N],t[N],z[N];
inline void Rsort(){
    for(int i=1;i<=n;i++)t[x[i]]++;
    for(int i=1;i<=n;i++)t[i]+=t[i-1];
    for(int i=n;i;i--)z[t[x[y[i]]]--]=y[i];
}

第一句话就是把所有元素的第一维全部丢到桶里去

第二句话就是把所有的桶前缀和,前缀和之后\(t[i]\)表示的是第一维(a)权值\(\le i\)的元素个数

前两句话都容易理解。

但是第三句话是个什么东西?那么多的数组调用是怎么回事?

别急,我们慢慢分析。

求出了\(t[i]\)之后,我们怎么求出元素现在的排名啊?

因为我们的\(t[i]\)表示的是第一维(a)权值\(\le i\)的元素个数

那么如果第一维(a)权值为\(i\)的元素的个数为\(c_i\)个,

那么权值为\(i\)的元素的排名区间就是\([t[i-1]+1=t[i]-c[i],t[i]]\)

而我们的只要对于每一个\(i\)令\(t[x[i]]--\)就可以保证结果的第一维(a)一定是符合要求的

像这样

    for(int i=1;i<=n;i--)z[t[x[i]]]=i,t[x[i]]--;

即

    for(int i=1;i<=n;i--)z[t[x[i]]]=i,t[x[i]]--;

但这样无法满足第二维符合要求,怎么办呢?

我们发现上面的代码中\(i\)的枚举顺序是可以改变而不影响第一维(a)排序后符合要求这个条件的

于是我们现在就是要找到一种枚举\(i\)的顺序,使得第二维(b)排序后也符合要求

我们知道在权值为\(i\)的所有元素中第一个使\(t[i]\)自减的元素得到的排序位置是最大的

所以我们按照倒序枚举\(i\)第二维的编号排名\(y[i]\),

    for(int i=n;i;i--)//change i to y[i]

这样第一个权值为\(i\)的所有元素中第一个使\(t[i]\)自减的元素的第二维肯定是最大的。

所以这样排序就符合要求啦

    for(int i=n;i;i--)z[t[x[y[i]]]--]=y[i];

主体部分

这里都是一些细节类的东西,我就直接放在注释里啦

inline void getsa(){
    for(int i=1;i<=n;i++)y[i]=i,t[x[i]=a[i]]++;Rsort();
    for(int k=1,p;k<=n;k<<=1){
        p=0;
        for(int i=n-k+1;i<=n;i++)y[++p]=i;
        //最后k位是没有权值的,并且已经排好序,因此第二维的值为0,需要放在最前面
        for(int i=1;i<=n;i++)if(sa[i]>k)y[++p]=sa[i]-k;
        //这里按照后缀的排名进行正序枚举,枚举第二维可能出现的后缀位置,如果$sa[i]>k$证明这个后缀会后缀$sa[i]-k$作为二元组,它在第二维中的排名肯定是所有未枚举中最靠前的
        Rsort();
        swap(x,y);
        //此时y变成了x,即原序号;
        //我们应当记得我们是要对(x[i],x[i+k])的二元组进行排序
        x[sa[1]]=p=1;
        for(int i=2,p0,p1;i<=n;i++){
            p0=sa[i-1];p1=sa[i];
            x[p1]=(y[p0]==)?p:++p;
        }
        //仍然正序枚举后缀的排名,离散化
        //枚举sa[i]其实就是枚举基数排序后的第i个元素
    }
}

完整代码

int n,m,sa[N],x[N],y[N],t[N];
char s[N];
il bool cmp(int i,int j,int k){return y[i]==y[j]&&y[i+k]==y[j+k];}
il void getsa(){
    m=200;for(RG int i=1;i<=n;i++)t[x[i]=(s[i]-'0')]++;
    for(RG int i=1;i<=m;i++)t[i]+=t[i-1];
    for(RG int i=n;i;i--)sa[t[x[i]]--]=i;
    for(RG int k=1,p;k<=n;k<<=1){
        p=0;
        for(RG int i=0;i<=m;i++)t[i]=y[i]=0;
        for(RG int i=n-k+1;i<=n;i++)y[++p]=i;
        for(RG int i=1;i<=n;i++)if(sa[i]>k)y[++p]=sa[i]-k;
        for(RG int i=1;i<=n;i++)t[x[y[i]]]++;
        for(RG int i=1;i<=m;i++)t[i]+=t[i-1];
        for(RG int i=n;i;i--)sa[t[x[y[i]]]--]=y[i];
        swap(x,y);x[sa[1]]=p=1;
        for(RG int i=2;i<=n;i++)x[sa[i]]=(cmp(sa[i],sa[i-1],k)?p:++p);
        if(p>=n)break;m=p;
    }
}

后缀数组的一些性质

摘自:

http://hihocoder.com/problemset/problem/1403,

http://hihocoder.com/problemset/problem/1407,

http://hihocoder.com/problemset/problem/1415,

http://hihocoder.com/problemset/problem/1419,

有删改

Height数组

定义\(Height\)数组表示排名为\((i-1)\)的后缀和排名为\(i\)的后缀的最长公共前缀(Longest Common Prefix,LCP)。

即\(Height[i]=LCP(i-1,i)\)

1:若\(rank_j<rank_k\)，则有\(LCP(j,k)=min_{i=1}^{rank[k]-rank[j]}Height[rank[j]+i]\)

这个性质显然。

因此，我们可以使用\(ST\)表在\(O(nlogn)+O(1)\)的时间内快速查询两个后缀的\(LCP\)

int S[21][N],p[N],lg[N],ans;
il void init(){
	p[0]=1;for(RG int i=1;p[i-1]<=n;i++)p[i]=p[i-1]*2;
	for(RG int i=1;i<=n;i++)lg[i]=lg[i>>1]+1;
	for(RG int i=1;i<=n;i++)lg[i]--;
	for(RG int i=1;i<=n;i++)S[0][i]=height[i];
	for(RG int k=1;p[k]<=n;k++)
		for(RG int i=1;i+p[k-1]<=n;i++)
			S[k][i]=min(S[k-1][i],S[k-1][i+p[k-1]]);
}
il int lcp(int l,int r){
	l=rk[l];r=rk[r];if(l>r)swap(l,r);l++;
	return min(S[lg[r-l+1]][l],S[lg[r-l+1]][r-p[lg[r-l+1]-1]]);
}

2:\(Height[rank[i]]\ge Height[rank[i-1]]-1\)

假设将所有后缀排序后，第\((i-1)\)个后缀的前一个后缀是第\(k\)个后缀，

即\(rank[i-1]=rank[k]+1\)，\(Height[rank[i-1]]=LCP(k,i-1)\)

我们可以知道第\((k+1)\)个后缀一定在第\(i\)个后缀的前面(此时\(Height[rank[i-1]]>1\))，

那么\(LCP(k+1,i)=LCP(k,i-1)-1=Height[rank[i-1]]-1\)

因此\(Height[rank[i-1]]-1=min_{j=1}^{rank[i]-rank[k+1]}Height[rank[k+1]+j]\)

所以有\(Height[rank[i]]\ge Height[rank[i-1]]-1\)

有了这个性质我们就可以再\(O(n)\)的时间内求出一个字符串的\(Height\)数组

这里是代码

int height[N],rk[N];//rk表示rank数组
il void getheight(){
	for(RG int i=1;i<=n;i++){//求后缀i的height
		height[rk[i]]=height[rk[i-1]]?height[rk[i-1]]-1:0;
		while(a[sa[rk[i]-1]+height[rk[i]]]==a[i+height[rk[i]]])
			height[rk[i]]++;
	}
}

求区间内本质不同子串数目

考虑\(height\)数组是怎样体现重复子串的。

因为每个子串一定是原串后缀的一个前缀,那么当出现一对长为\(len\)的相同子串的时候,

这对相同子串各自的后缀就一定会有长为\(len\)的一段前缀相同。

而\(height\)数组正好表示的就是后缀排序中相邻前缀的\(lcp\)长度。

更为清晰的说法是,对于一个重复出现的子串,这些子串对应的后缀后缀排序后一定是连续的一段。

而\(height[i]\)记录的就是经过\(i\)的连续段的数量

那么可以知道答案就是\(\frac{n(n+1)}{2}-\sum_{i}height[i]\),实际就是将每一段拆开来求。

求最长可重叠重复\(K\)次字串

重复子串即两后缀的公共前缀，因此重复子串的最大长度即\(Height\)数组的最大值

(已经将后缀按照字典序排好，不可能有字典序不相邻的后缀其\(LCP\)反而更大的情况)

求重复\(K\)次字串的最大长度，即求\(Height\)数组长度为\(K\)的连续一段的最小值的最大值

使用单调队列即可完成

int f[N],g[N],l=1,r,ans;
int main()
{
	n=read();k=read();
	for(RG int i=1;i<=n;i++)a[i]=read();
	getsa();getheight();
	for(RG int i=1;i<=n;i++){
		while(l<=r&&f[r]>=height[i])r--;
		f[++r]=height[i];g[r]=i;
		while(l<=r&&g[l]<=i-k+1)l++;
		ans=max(ans,f[l]);
	}
	printf("%d\n",ans);
	return 0;
}

求最长不可重叠重复子串问题

考虑二分答案;

检查字符串中是否有长度为\(K\)的不可重叠重复子串时，找到\(Height\le K\)的连续的一段，查出这段中后缀位置的最大值和最小值之差，

如果某一段的差值\(\le K\)则可行，否则不可行

il bool check(int k){
	for(RG int i=1,mn=inf,mx=0;i<=n;i++){
		if(height[i]>=k){
			mn=min(mn,min(sa[i-1],sa[i]));
			mx=max(mx,max(sa[i-1],sa[i]));
			if(mx-mn>=k)return 1;
		}
		else{mn=inf;mx=0;}
	}
	return 0;
}
int main()
{
	n=read();
	for(RG int i=1;i<=n;i++)a[i]=read();
	getsa();getheight();
	RG int l=1,r=n,mid,ans=0;
	while(l<=r){
		RG int mid=((l+r)>>1);
		if(check(mid))ans=mid,l=mid+1;
		else r=mid-1;
	}
	printf("%d\n",ans);
	return 0;
}

求最长公共字串

两个串

将这两个串拼到一起，中间使用一个不在两个串中出现过的字符，之后求出这个合并串的\(Height\)

那么最长公共字串就是不在同一个分串中的后缀\(Height\)的最大值

int main()
{
	scanf("%s",s+1);n1=strlen(s+1);
	s[++n1]='z'+1;scanf("%s",s+n1+1);n2=strlen(s+1);
	for(RG int i=1;i<=n2;i++)a[i]=s[i]-'a'+1;
	getsa();getheight();
	for(RG int i=2;i<=n2;i++)
		if((sa[i]<n1)^(sa[i-1]<n1))
			ans=max(ans,height[i]);
	printf("%d\n",ans);return 0;
}

多个串

仍然拼到一起，需要使用尺取法枚举左端点

求重复次数最多的连续字串

考虑枚举串长\(L\)，可以知道\(k=LCP(i,i+L)/L+1\)就是以\(i\)开头，长度为\(L\)的循环次数

对于每次枚举，只考虑枚举\(L\)的倍数部分

如果不是\(L\)的倍数部分次数超过了\(k\)，那么这个部分的结尾一定在

\([i+L*k,i+L*k-1+LCP(i,i+L)\%L]\)之间

此时\(LCP(i-(k-LCP(i,i+L)\%L),i+k-(k-LCP(i,i+L)\%L))\)一定只比\(k\)大\(1\)

于是每次枚举的复杂度为\(O(\frac{n}{L})\)

总复杂度是\(O(nlogn)\)

int main()
{
	scanf("%s",s+1);n=strlen(s+1);
	for(RG int i=1;i<=n;i++)a[i]=s[i]-'a'+1;
	getsa();getheight();
	init();
	for(RG int k=1,len,els;k+k<=n;k++)
		for(RG int i=k;i+k<=n;i+=k){
			len=lcp(i,i+k);ans=max(ans,len/k+1);
			if((els=lcp(i+len%k-k,i+len%k)/k+1)==len/k+2)
				ans=max(ans,els);
		}
	printf("%d\n",ans);
	return 0;
}