这里简单介绍一下倍增算法((O(nlogn)))求后缀数组
定义
定义(S)是长度为(n)的字符串，后缀(suf[i])指(S[isim n])；
将(S)的所有后缀按字典序排序：
- (rk[i](rank[i]))指(suf[i])的排名；
- (sa[i])指第(i)名的后缀是(suf[sa[i]])；
- (height[i])指第(i)名和第(i-1)名后缀的最长公共前缀((lcp))；
算法原理
sa数组求法
求得(sa)数组也就求得了(rk)；
首先我们可以很容易想到一个快排实现的算法，如果基于逐字符比较的算法时间是(O(n^2logn))；
我们也可以想到一个优化，用(Hash+)二分代替逐字符比较，这样时间是(O(nlog^2n))；
另外的想法：
可以把每个后缀看成由(ASCII)码构成的数列，用基数排序来实现，这样时间是(O(n^2))的；
想办法优化：
因为待排序的字符串都是(S)上面的后缀，它们是有相同部分的；
这样我们可以引入这样的一个算法：
1.对于每个后缀的第一个字符进行一次排序，得到它们的排名作为每一个后缀的第一关键字；
2.对于每个后缀的前两（1+1）个字符进行一次排序，（将(suf[i])的前两个字符(S[i],S[i+1])，看做一个整体进行排序，由于第一步已经的到了长度为1的子串的排名，这里就等价于将它们的排名进行合并后再排序），再得到它们的排名作为每一个后缀的第一关键字；
3.对于每个后缀的前三个（1+2）个字符进行依次排序，再得到它们的排名作为每一个后缀的第一关键字；
4.对于每个后缀的前五个（1+4）个字符进行依次排序，
······
直到所有排名都互不相同；
看图片更好理解，就是一个不停排序合并再排序的过程，每次合并时都能保证是上一步已经解决的问题，且对于每一个后缀都能不重不漏地包含所有字符，因此这样的排序效果上是等价于暴力基数排序的；
又由于合并长度是倍增实现的，所以最多进行(log_2n)次排序，而每次排序都使用位数为(2)的基数排序，就能使算法时间复杂度维持在(O(nlogn))级别；
这部分的的代码
#include<bits/stdc++.h>
#define ll long long
#define mp make_pair
using namespace std;
const int N=100005;
char c[N];
int n,m=127;//m是值域的初始大小
int tub[N];//桶
int fk[N],psk[N];//注意！！！fk(first key)是某个位置的一关键字
//而psk(pos of second key)是 排名为i的二关键字所在的位置
int sa[N],height[N],rk[N];
//ll ans;
inline int read()
{
int x=0,fl=1;char st=getchar();
while(st<'0'||st>'9'){ if(st=='-')fl=-1; st=getchar();}
while(st>='0'&&st<='9') x=x*10+st-'0',st=getchar();
return x*fl;
}
inline void rsort()//基数排序
{
for(int i=1;i<=m;i++) tub[i]=0;//清空桶
for(int i=1;i<=n;i++) ++tub[fk[i]];//将第一关键字加入桶中
for(int i=1;i<=m;i++) tub[i]+=tub[i-1];//求桶的前缀和，得到一关键字的排名
for(int i=n;i>=1;i--) sa[tub[fk[psk[i]]]--]=psk[i];//按照从后到前的顺序，依据二关键字的排名得到目前的sa
}
inline void SA()
{
for(int i=1;i<=n;i++) fk[i]=c[i],psk[i]=i; //初始
rsort();//第一次排序
for(int k=1;k<=n;k<<=1)//合并的长度
{
int cnt=0;
for(int i=n-k+1;i<=n;i++) psk[++cnt]=i;//这一部分位置是没有能与其合并的 ，其二关键字应是最小的
for(int i=1;i<=n;i++)
if(sa[i]>k) psk[++cnt]=sa[i]-k; //这里的sa[i]会被某个位置合并，这个位置是sa[i]-k
//这一部分的二关键字是按照顺序加入的
rsort();
swap(fk,psk);//将fp放到psk转存，方便得到下一次的一关键字
fk[sa[1]]=1;
cnt=1;
for(int i=2;i<=n;i++) //如果两个位置的一关键字和二关键字都相同，则排名不同，需要+1
fk[sa[i]]=(psk[sa[i]]==psk[sa[i-1]]&&psk[sa[i]+k]==psk[sa[i-1]+k])?cnt:++cnt;
if(cnt==n) break;//如果已经所有排名不同了就可以退出
m=cnt;//更新值域
}
}
int main()
{
n=read();
scanf("%s",c+1);
SA();
// get_height();
// ans=(ll) n*(n+1)/2;
// for(int i=1;i<=n;i++)
// ans-=height[rk[i]];
// printf("%lld",ans);
return 0;
}
height数组的求法
主要依靠一个性质：
(height[rk[i]] ≥ height[rk[i-1]]-1)
感性证明：
假设排在(suf[i-1])前面的那个串是(suf[k])它们的最长公共前缀长度为(height[rk[i-1]])；
(suf[i])比(suf[i-1])少了它的第一个字符，可得(suf[i])与(suf[k+1])的最长公共前缀是(height[rk[i-1]]-1)；
但(suf[i])与(suf[k+1])在排序后不一定在一起（即(height[rk[i]])不一定是它们的最长公共前缀），
可是就算不在一起，在排好序的后缀中(suf[k+1])与(suf[i])之间的后缀都一定满足，与(suf[i])的最长公共前缀至少是(height[rk[i-1]]-1)；
那么一定有(height[rk[i]] ≥ height[rk[i-1]]-1)；
这样就可以得到一个(O(n))的代码
inline void get_height()
{
int k=0;
for(int i=1;i<=n;++i) rk[sa[i]]=i;
for(int i=1;i<=n;++i) //i是位置不是排名
{
if(k)--k;//-1
int j=sa[rk[i]-1];//找到排名前一个的位置
while(j+k<=n&&i+k<=n&&c[i+k]==c[j+k])++k;//继续匹配
height[rk[i]]=k;
}
}
一些应用
询问任意两个后缀的lcp
可以得知(suf[i])与(suf[j])（(rk[i]<rk[j])）的(lcp)长度就是(minlimits_{k=rk[i]+1}^{rk[j]}height[k])；
这就变成一个区间最小值的问题了；
本质不同的子串
串(S)的所有子串个数是(n*(n+1)/2)；
串(S)的所有子串也可以由，所有后缀的前缀得来；
其中相同的有(sum height[i])个；
所以有：
两个串的最长公共子序列
(Dp)会超时的那种；
一个简单的做法是：
将两个串合并成一个串，并且中间用一个不会出现的字符隔开（如%），求出新串的后缀数组；
求出一个最大的(height[i])，满足(sa[i])和(sa[i-1])在不同的串里面；
这个做法可以推广到多个串的最长公共子序列，但时间也会增加；
出现次数大于等于k的最长子串
找出，长度为(k-1)的序列的(height[])的最小值，的最大值；