后缀数组（Suffix Array）

最新推荐文章于 2022-12-11 10:29:02 发布

CaptainHarryChen

最新推荐文章于 2022-12-11 10:29:02 发布

阅读量591

点赞数 1

分类专栏： OI知识总结字符串算法文章标签：算法字符串处理后缀数组后缀

本文链接：https://blog.csdn.net/can919/article/details/54731293

版权

OI知识总结同时被 2 个专栏收录

37 篇文章 3 订阅

订阅专栏

字符串算法

2 篇文章 0 订阅

订阅专栏

后缀数组是处理字符串的有力工具。

3个数组：Sa、Rank、Height

Sa存储一个字符串按字典序排列的后缀，如图
Sa数组内容
Rank数组存储后缀i的名次，就是把Sa反过来，上图中
Rank[1]==2,Rank[2]==8…
Height数组存储相邻两个Sa后缀之间公共前缀的长度，如图
Height数组内容

求出Sa和Rank

处理后缀树组有两种算法：倍增、DC3
（我只会倍增，所以只写倍增。。。）
首先得搞懂基数排序：基数排序-百度百科

思路：用倍增的方法对每个字符开始的长度为 $2^k$ 子字符串进行排序，求出排名，即 rank 值。k从0开始，每次加，当 $2^k$ 大于n以后，每个字符开始的长度为 $2^k$ 的子字符串便相当于所有的后缀。并且这些子字符串都一定已经比较出大小，即rank值中没有相同的值，那么此时的rank值就是最后的结果。每一次排序都利用上次长度为 $2^{k-1}$ 的字符串的rank值，那么长度为 $2^k$ 的字符串就可以用两个长度为 $2^{k-1}$ 的字符串的名排作为关键字表示，然后进行基数排序，便得出了长度为 $2^k$ 的字符串的rank值。

Height数组

Height的作用

可以求出任意两个后缀的最长公共前缀。

性质1

后缀(j)和后缀(k)的最长公共前缀为height[rank[j]+1]，height[rank[j]+2]，height[rank[j]+3]，…，height[rank[k]]中的最小值。

解释：
用Height求最长公共前缀
首先这些后缀都是按照字典序排列过的，也就是说当第k位为a时，下一个后缀第k位变成了b，那么第k位以后就永远不会变回a了。那么Height区间最小值意思就是在这个区间内，最靠前的变化位。如上图，最小值1是因为第4排第2位的a变成了b，使得我们要求的两个后缀的第二位也肯定不一样，所以他们的最长公共前缀为1。

求出Height

首先得理解一个性质

性质2

Height[rank[i]]>=Height[rank[i-1]]-1。

解释：如下图，红色代表后缀(i-1)，深蓝色代表后缀(i)，黄色代表后缀(k)，即排名在红色前面的那一个，深绿色为它们的最长公共前缀，即height[rank[i-1]]。那么必定有一个后缀(k+1)浅蓝色，和深蓝色的最长公共前缀为height[rank[i-1]]，即浅绿色（比深绿色少一格）。又因为性质1，所以浅蓝色与深蓝色排名的中间的height值最小为浅绿色长度，所以height[rank[i]]（深蓝色与他前一名的最长公共前缀）一定是≥浅绿色的，即height[rank[i]]≥height[rank[i-1]]-1。
Height的性质

利用这个性质，Height就可以用一个标记记录Height[rank[i-1]]，减少枚举次数。

代码及注释

集训队论文的代码太难理解了，这里是我的代码：
这份代码较长，但便于初学者理解，后面第二篇为简化版

#include<cstdio>
#include<cstring>
#define MAXN 2005
#define MAX_NUM 256
char S[MAXN];
namespace SuffixArray
{
    int A[MAXN],B[MAXN],cntA[MAXN],cntB[MAXN],tsa[MAXN];
    void getSa(char str[],int n,int sa[],int rank[])
    {
        str[++n]=0;
        memset(cntA,0,sizeof cntA);
		//基数排序出每组一个字符时的情况
        for(int i=1;i<=n;i++)
            cntA[(int)str[i]]++;
        for(int i=1;i<MAX_NUM;i++)
            cntA[i]+=cntA[i-1];
        for(int i=n;i>0;i--)
            sa[--cntA[(int)str[i]]]=i;
		//处理重复的rank值（排序未完成时相邻的rank值可能重复）
        rank[sa[0]]=0;
        for(int i=1;i<n;i++)
            rank[sa[i]]=rank[sa[i-1]]+(str[sa[i-1]]!=str[sa[i]]);
        //len倍增处理
        for(int len=1;rank[sa[n-1]]<n-1/*当rank没有重复值时*/;len<<=1)
        {
            memset(cntA,0,sizeof cntA);
            memset(cntB,0,sizeof cntB);
            for(int i=0;i<n;i++)
            {
                cntA[A[i]=rank[i]]++;//前半段关键字
                cntB[B[i]=i+len<n?rank[i+len]:0]++;//后半段关键字
            }
            for(int i=1;i<n;i++)
            {
                cntA[i]+=cntA[i-1];
                cntB[i]+=cntB[i-1];
            }
			//基数排序后半段关键字
            for(int i=n-1;i>=0;i--)
                tsa[--cntB[B[i]]]=i;
            //在后半段的基础上基数排序前半段关键字
            for(int i=n-1;i>=0;i--)
                sa[--cntA[A[tsa[i]]]]=tsa[i];
            //处理重复rank值
            rank[sa[0]]=0;
            for(int i=1;i<n;i++)
                rank[sa[i]]=rank[sa[i-1]]
                +(A[sa[i]]!=A[sa[i-1]]
                ||B[sa[i]]!=B[sa[i-1]]);
        }
    }
    void getHeight(char str[],int n,int sa[],int rank[],int Height[])
    {
        for(int i=1,k=0;i<=n;i++)
        {
            k=k>0?k-1:0;//k标记Height[rank[i-1]]-1
            while(str[i+k]==str[sa[rank[i]-1]+k])
                k++;
            //枚举求出Height值
            Height[rank[i]]=k;
        }
    }
}
int R[MAXN],Sa[MAXN],H[MAXN];
int main()
{
    int n;
    scanf("%s",S+1);
    n=strlen(S+1);
    SuffixArray::getSa(S,n,Sa,R);
    SuffixArray::getHeight(S,n,Sa,R,H);
    for(int i=1;i<=n;i++)
    {
        printf("Sa[%2d]=%2d:  ",i,Sa[i]);
        for(int j=Sa[i];j<=n;j++)
            printf("%c",S[j]);
        printf("\n");
    }
    printf("\n");
    for(int i=2;i<=n;i++)
        printf("Hight[%d~%d]=%d\n",i-1,i,H[i]);
    return 0;
}

简化版代码，效率高，代码复杂度更低，需利用一个性质

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int MAXN=2005;

int n;
char str[MAXN];
int sa[MAXN],rk[MAXN],h[MAXN];
int cnt[MAXN],tsa[MAXN],trk[MAXN];

void GetSa()
{
	//基数排序出每组一个字符时的情况
	for(int i=1;i<=n;i++)
		cnt[(int)str[i]]++;
	for(int i=1;i<128;i++)
		cnt[i]+=cnt[i-1];
	for(int i=n;i>0;i--)
		sa[cnt[(int)str[i]]--]=i;
	//处理重复的rank值（排序未完成时相邻的rank值可能重复）
	for(int i=1;i<=n;i++)
		rk[sa[i]]=rk[sa[i-1]]+(str[sa[i]]!=str[sa[i-1]]);
	//len倍增处理
	for(int len=1;rk[sa[n]]<n;len<<=1)
	{
		/*
		如果将此时的sa[i]全部减len，不能减的sa[i]全部排到最前面
		得到的序列就是对当前len，按后半截关键字排序的结果
		于是我们就不需要专门写安后半截关键字排序的代码了
		*/
		
		//此时为前半截关键字基数排序
		for(int i=1;i<=n;i++)
			cnt[rk[sa[i]]]=i;//sa[i]的关键字的排名一定为i（sa[i]之前有i-1个）
		for(int i=n;i>0;i--)
			if(sa[i]>len)//sa[i]能减len的项在后关键字排序中排在后面的，先排序
				tsa[cnt[rk[sa[i]-len]]--]=sa[i]-len;//sa[i]的前半截关键字为rk[sa[i]-len]
		//将sa[i]不能减len的排在前面，此时来排序
		for(int i=n;i>n-len;i--)
			tsa[cnt[rk[i]]--]=i;
		//处理重复rank
		for(int i=1;i<=n;i++)
			trk[tsa[i]]=trk[tsa[i-1]]+(rk[tsa[i]]!=rk[tsa[i-1]]||rk[tsa[i]+len]!=rk[tsa[i-1]+len]);
		swap(sa,tsa);
		swap(rk,trk);
	}
}
void GetH()
{
	int k=0;
	for(int i=1;i<=n;i++)
	{
		k=k>0?k-1:k;//k标记Height[rank[i-1]]-1
		while(str[i+k]==str[sa[rk[i]+1]+k])
			k++;
		//枚举求出Height值
		h[rk[i]]=k;
	}
}

int main()
{
	scanf("%s",str+1);
	n=strlen(str+1);
	GetSa();
	GetH();
	for(int i=1;i<=n;i++)
	{
		printf("Sa[%2d]=%2d:  ",i,sa[i]);
		for(int j=sa[i];j<=n;j++)
			printf("%c",str[j]);
		printf("\n");
	}
	printf("\n");
	for(int i=1;i<n;i++)
		printf("Hight[%d~%d]=%d\n",i,i+1,h[i]);
	return 0;
}

代码易错点

至少是我错过的。。。

for(int len=1;rk[sa[n]]<n;len<<=1)条件误写为rk[n]<n
rk1[sa1[i]]=rk1[sa1[i-1]]+(...)下标误写为rk1[i]
height数组for循环i应从1枚举到n，而不是n-1（虽然height数组实际只有n-1项，但求的时候，对于每一个i，我们求出的是h[rk[i]]，我们并不知道哪一项不存在）
各种地方tsa与sa搞混

CaptainHarryChen

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
后缀数组（Suffix Array）

后缀数组是处理字符串的有力工具。3个后缀数组：Sa、Rank、HeightSa存储一个字符串按字典序排列的后缀，如图 Rank数组存储后缀i的名次，就是把Sa反过来，上图中 Rank[1]==2,Rank[2]==8…… Height数组存储相邻两个Sa后缀之间公共前缀的长度，如图求出Sa和Rank处理后缀树组有两种算法：倍增、DC3 （我只会倍增，所以只写...
复制链接

扫一扫