ACM常用模板——数据结构——后缀数组

参考罗穗骞的论文模板：

#include<cstdio>

#include<iostream>

#include<cmath>

#include<cstring>

#include<algorithm>

#include<set>

#include<map>

#include<queue>

#include<vector>

#definemaxn1000005

#definepbpush_back

#defineLLlonglong

#defineMS(a,b)memset(a,b,sizeof(a))

#defineFI(a,b)fill(a,a+maxn,b)

#definesf(n)scanf("%d",&n)

#definesf2(a,b)scanf("%d%d",&a,&b)

#definepf(n)printf("%d\n",n)

#defineffr(i,n)for(i=0;i<n;i++)

usingnamespacestd;

intRank[maxn],tmp[maxn],sa[maxn],height[maxn];

intn,k;

boolcompare_sa(inti,intj)

{

if(Rank[i]!=Rank[j])returnRank[i]<Rank[j];

else{

intri=i+k<=n?Rank[i+k]:-1;

intrj=j+k<=n?Rank[j+k]:-1;

returnri<rj;

}

}

//计算字符串后缀数组sa

voidconstru_sa(stringS)

{

inti;

n=S.length();

for(i=0;i<=n;i++){

sa[i]=i;

Rank[i]=i<n?S[i]:-1;

}

for(k=1;k<=n;k*=2){

sort(sa,sa+n+1,compare_sa);

tmp[sa[0]]=0;

for(i=1;i<=n;i++){

tmp[sa[i]]=tmp[sa[i-1]]+(compare_sa(sa[i-1],sa[i])?1:0);

}

for(i=0;i<=n;i++){

Rank[i]=tmp[i];

}

}

}

//高度数组height[i]:代表第i和i+1个后缀的最长公共前缀

voidconstruct_lcp(stringS)

{

intn=S.length(),i;

for(i=0;i<=n;i++)Rank[sa[i]]=i;

inth=0;

height[0]=0;

for(i=0;i<n;i++){

intj=sa[Rank[i]-1];

if(h>0)h--;

for(;j+h<n&&i+h<n;h++){

if(S[j+h]!=S[i+h])break;

}

height[Rank[i]]=h;

}

}

//字符串匹配

intcontain(stringS,stringT)

{

inta=0,b=S.length();

while(b-a>1){

intc=(a+b)/2;

if(S.compare(sa[c],T.length(),T)<0)a=c;

elseb=c;

}

if(S.compare(sa[b],T.length(),T)==0)returnsa[b];

elsereturn-1;

}

intmain()

{

strings,t;

inti;

while(cin>>s>>t){//s是原串，t是匹配串

constru_sa(s);

construct_lcp(s);

intlen=s.size();

printf("sa:\n");

for(i=0;i<=len;i++){printf("%d",sa[i]);}printf("\n");

printf("rank:\n");

for(i=0;i<=len;i++){printf("%d",Rank[i]);}printf("\n");

printf("height:\n");

for(i=0;i<=len;i++){printf("%d",height[i]);}printf("\n");

cout<<contain(s,t)<<endl;

}

return0;

}

(一)最长公共前缀height[i]=suffix(sa[i-1])和suffix(sa[i])的最长公共前缀，也就是排名相邻的两个后缀的最长公共前缀。那么对于j和k，不妨设rank[j]<rank[k],则有以下性质：suffix(j)和suffix(k)的最长公共前缀为height[rank[j]+1],height[rank[j]+2],height[rank[j]+3],…,height[rank[k]]中的最小值。例如，字符串为“aabaaaab”，求后缀“abaaaab”和后缀“aaab”的最长公共前缀例如，字符串为“aabaaaab”，求后缀“abaaaab”和后缀“aaab”的最长公共前缀例1：最长公共前缀给定一个字符串，询问某两个后缀的最长公共前缀。算法分析：按照上面所说的做法，求两个后缀的最长公共前缀可以转化为求某个区间上的最小值。对于这个RMQ问题（如果对RMQ问题不熟悉，请阅读其他相关资料），可以用O(nlogn)的时间先预处理，以后每次回答询问的时间为O(1)。所以对于本问题，预处理时间为O(nlogn)，每次回答询问的时间为O(1)。如果RMQ问题用O(n)的时间预处理，那么本问题预处理的时间可以做到O(n)。hdu4691后缀数组：寻找前一个区间与当前区间的前缀字符数目最多为多少

#include<cstdio>

#include<cstring>

#include<algorithm>

usingnamespacestd;

#defineLLlonglong

#defineN100010

chars[N];

intm,n,len;

intt[N],t2[N],c[N],height[N],sa[N],rank[N],dp[N][20],cnt[N];

//sa代表等级为i的下标

//rank代表下标为i的等级

//height代表字符串由最低位排序到最高位相邻两个字符串的前缀相同个数

voidbuild_sa()

{

m=27;

int*x=t,*y=t2;

for(inti=0;i<m;++i)c[i]=0;

for(inti=0;i<n;++i)++c[x[i]=cnt[i]];

for(inti=1;i<m;++i)c[i]+=c[i-1];

for(inti=n-1;i>=0;--i)sa[--c[x[i]]]=i;

for(intk=1;k<=n;k<<=1)

{

intp=0;

for(inti=n-k;i<n;++i)y[p++]=i;

for(inti=0;i<n;++i)if(k<=sa[i])y[p++]=sa[i]-k;

for(inti=0;i<m;++i)c[i]=0;

for(inti=0;i<n;++i)++c[x[y[i]]];

for(inti=1;i<m;++i)c[i]+=c[i-1];

for(inti=n-1;i>=0;--i)sa[--c[x[y[i]]]]=y[i];

swap(x,y);

p=1,x[sa[0]]=0;

for(inti=1;i<n;++i)

x[sa[i]]=y[sa[i]]==y[sa[i-1]]&&y[sa[i]+k]==y[sa[i-1]+k]?p-1:p++;

if(p>=n)break;

m=p;

}

}

voidget_height()

{

for(inti=0;i<=len;++i)rank[sa[i]]=i;

for(inti=0,k=0;i<len;++i)

{

if(k)--k;

if(rank[i]-1<0)continue;

intj=sa[rank[i]-1];

while(cnt[i+k]==cnt[j+k])++k;

height[rank[i]]=k;

}

}

intRMQ(intL,intR)

{

intk=0;

while((1<<(k+1))<=R-L+1)++k;

returnmin(dp[L][k],dp[R-(1<<k)+1][k]);

}

voidRMQ_init()

{

for(inti=0;i<=len;++i)dp[i][0]=height[i];

for(intj=1;(1<<j)<=len;++j)

for(inti=1;i+(1<<j)-1<=len;++i)

dp[i][j]=min(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);

}

intlcp(inta,intl)

{

if(a==l)returnlen-a;

intu=rank[a],v=rank[l];

if(u>v)returnRMQ(v+1,u);

elsereturnRMQ(u+1,v);

}

intcal(intp)

{

intv=p;

for(inti=1;;++i)

if(v/10==0)returni;

elsev/=10;

}

intmain()

{

//freopen("in.txt","r",stdin);

while(scanf("%s",s)!=EOF)

{

len=strlen(s);

for(inti=0;i<len;++i)cnt[i]=s[i]-'a'+1;

cnt[len]=0;

n=len+1;

build_sa();

get_height();

RMQ_init();

intt,a,b,l,r;

LLans1,ans2;

scanf("%d",&t);

scanf("%d%d",&a,&b);

ans1=b-a+1;

ans2=b-a+3;

--t;

while(t--)

{

scanf("%d%d",&l,&r);

ans1=ans1+r-l+1;

intp=min(lcp(a,l),min(b-a,r-l));

ans2=ans2+(r-l)-p+2+cal(p);

a=l,b=r;

}

printf("%I64d%I64d\n",ans1,ans2);

}

return0;

}

（二）重复子串：字符串R在字符串L中至少出现两次，则称R是L的重复子串。例2：可重叠最长重复子串给定一个字符串，求最长重复子串，这两个子串可以重叠。算法分析：这道题是后缀数组的一个简单应用。做法比较简单，只需要求height数组里的最大值即可。首先求最长重复子串，等价于求两个后缀的最长公共前缀的最大值。因为任意两个后缀的最长公共前缀都是height数组里某一段的最小值，那么这个值一定不大于height数组里的最大值。所以最长重复子串的长度就是height数组里的最大值。这个做法的时间复杂度为O(n)。（三）不可重叠最长重复子串（pku1743）给定一个字符串，求最长重复子串，这两个子串不能重叠。算法分析：这题比上一题稍复杂一点。先二分答案，把题目变成判定性问题：判断是否存在两个长度为k的子串是相同的，且不重叠。解决这个问题的关键还是利用height数组。把排序后的后缀分成若干组，其中每组的后缀之间的height值都不小于k。例如，字符串为“aabaaaab”，当k=2时，后缀分成了4组，如图5所示。容易看出，有希望成为最长公共前缀不小于k的两个后缀一定在同一组。然后对于每组后缀，只须判断每个后缀的sa值的最大值和最小值之差是否不小于k。如果有一组满足，则说明存在，否则不存在。整个做法的时间复杂度为O(nlogn)。本题中利用height值对后缀进行分组的方法很常用，请读者认真体会。

#definemaxn20010

intwa[maxn],wb[maxn],wv[maxn],wss[maxn];

intr[maxn],sa[maxn];

intcmp(int*r,inta,intb,intl)

{returnr[a]==r[b]&&r[a+l]==r[b+l];}

/*【倍增算法O(nlgn)】待排序的字符串放在r数组中，从r[0]到r[n-1]，长度为n，且最大值小于m

使用倍增算法前，需要保证r数组的值均大于0。然后要在原字符串后添加一个0号字符

所以，若原串的长度为n，则实际要进行后缀数组构建的r数组的长度应该为n+1.所以调用da函数时，对应的n应为n+1.

*/

voidda(int*r,int*sa,intn,intm){//n要加1

inti,j,p,*x=wa,*y=wb,*t;

for(i=0;i<m;i++)wss[i]=0;

for(i=0;i<n;i++)wss[x[i]=r[i]]++;

for(i=1;i<m;i++)wss[i]+=wss[i-1];

for(i=n-1;i>=0;i--)sa[--wss[x[i]]]=i;

for(j=1,p=1;p<n;j*=2,m=p){

for(p=0,i=n-j;i<n;i++)y[p++]=i;

for(i=0;i<n;i++)if(sa[i]>=j)y[p++]=sa[i]-j;

for(i=0;i<n;i++)wv[i]=x[y[i]];

for(i=0;i<m;i++)wss[i]=0;

for(i=0;i<n;i++)wss[wv[i]]++;

for(i=1;i<m;i++)wss[i]+=wss[i-1];

for(i=n-1;i>=0;i--)sa[--wss[wv[i]]]=y[i];

for(t=x,x=y,y=t,p=1,x[sa[0]]=0,i=1;i<n;i++)

x[sa[i]]=cmp(y,sa[i-1],sa[i],j)?p-1:p++;

}

return;

}

intrank[maxn],height[maxn];//rank[i]：i排第几；sa[i]：排第i的后缀串在哪里，互为逆运算

voidcalheight(int*r,int*sa,intn){//n不用加1

inti,j,k=0;

for(i=1;i<=n;i++)rank[sa[i]]=i;

for(i=0;i<n;height[rank[i++]]=k){

for(k?k--:0,j=sa[rank[i]-1];r[i+k]==r[j+k];k++);

}

return;

}

intmain(){

intn;

while(scanf("%d",&n)&&n){

inti;

intx,y;

scanf("%d",&x);

for(i=0;i<n-1;i++){

scanf("%d",&y);

r[i]=y-x+100;//不能出现负数

x=y;

}cout<<endl;

r[n-1]=0;//总共有n-1个值

da(r,sa,n,190);

calheight(r,sa,n-1);

for(i=1;i<=n-1;i++)

cout<<height[i]<<endl;

intl=0,r=n-1;

intmid;

intans=0;

while(l<=r){

mid=(l+r)>>1;

intminm=sa[1];

intmaxm=sa[1];

boolok=0;

for(i=2;i<=n;i++){//不写i<=n-1的原因系这样可以处理完最后一组

if(height[i]>=mid&&i!=n){

if(sa[i]>maxm)maxm=sa[i];

if(sa[i]<minm)minm=sa[i];

}else{

if(maxm-minm>=mid){

ok=1;

break;

}elseminm=maxm=sa[i];

}

}

if(ok){

ans=mid;

l=mid+1;

}elser=mid-1;

}

//ans+1的原因是前面的处理是把后一个减去前一个的值，所以最后要+1个

if(ans+1<=4)printf("%d\n",0);

elseprintf("%d\n",ans+1);

}

return0;

}

（四）可重叠的k次最长重复子串（pku3261）给定一个字符串，求至少出现k次的最长重复子串，这k个子串可以重叠。算法分析：这题的做法和上一题差不多，也是先二分答案，然后将后缀分成若干组。不同的是，这里要判断的是有没有一个组的后缀个数不小于k。如果有，那么存在k个相同的子串满足条件，否则不存在。这个做法的时间复杂度为O(nlogn)。

/*

PKU3261MilkPatterns

*/

#include<stdio.h>

#include<memory.h>

#include<stdlib.h>

#defineMAX(a,b)((a)>(b)?(a):(b))

#defineMIN(a,b)((a)>(b)?(b):(a))

#defineN20005

#defineK35

intnday;

/***************************************/

intpower;

intlstrank[N];

intcmpstr[N];

intcmpChar(constvoid*a,constvoid*b){

returncmpstr[*(int*)a]-cmpstr[*(int*)b];

}

intcmpLst(constvoid*A,constvoid*B){

inta=*(int*)A;

intb=*(int*)B;

if(lstrank[a]==lstrank[b])

returnlstrank[a+power]-lstrank[b+power];

returnlstrank[a]-lstrank[b];

}

/*后缀数组

参数：

输入字符串str[];

返回后缀数组sa[];返回名次数组rank[]

说明：

复杂度O(nlogn)

需要stdlib.h辅助全局变量power,lstrank[],cmpstr[]

*/

voidsuffixArray(intstr[],intsa[],intrank[]){

inti,j,n=nday;

for(i=0;i<n;i++)sa[i]=i;

memcpy(cmpstr,str,sizeof(cmpstr));

qsort(sa,n,sizeof(int),cmpChar);

for(i=j=0;i<n;i++){

if(i>0&&str[sa[i]]!=str[sa[i-1]])j++;

rank[sa[i]]=j;

}

for(power=1;rank[sa[n-1]]<n-1;power*=2)

{

memcpy(lstrank,rank,sizeof(int)*n);

qsort(sa,n,sizeof(int),cmpLst);

for(i=j=0;i<n;i++){

if(i>0&&cmpLst(&sa[i-1],&sa[i]))j++;

rank[sa[i]]=j;

}

}

}

/*区间最大值询问

preRMQ()用O(nlogn)时间预处理

RMQ()用O(1)的时间询问i~j之间的最大值

*/

intdr[N][K]={0};

voidpreRMQ(inta[],intn){

inti,j,k,f,s;

for(i=0;i<n;i++)dr[i][0]=a[i];

for(s=f=1;s<n;f++){

for(i=0;;i++){

if(i+s>=n)break;

dr[i][f]=MIN(dr[i][f-1],dr[i+s][f-1]);

}

s=1<<f;

}

}

intRMQ(intp,intq){

intd,f;

d=q-p+1;

for(f=0;(1<<f)<=d;f++);f--;

returnMIN(dr[p][f],dr[q-(1<<f)+1][f]);

}

/*预处理LCP求h[],height[]

参数：

输入原字符串str[]

输入后缀数组sa[]

输入名次数组rank[]

返回height[]

说明：

复杂度O(n)

需要事先用suffixArray计算sa[]和rank[]

height[i]=LCP(i-1,i)

h[i]=height[rank[i]]

height[i]=h[sa[i]]

*/

voidpreLCP(intstr[],intsa[],intrank[],intheight[]){

inti,j,k,s,n=nday;

inth[N];

for(i=0;i<n;i++){

if(rank[i]==0){

h[i]=0;continue;

}

j=rank[i]-1;

k=rank[i];

if(i==0||h[i-1]<=1)s=0;

elses=h[i-1]-1;

for(;sa[k]+s<n&&sa[j]+s<n;s++)

if(str[sa[k]+s]!=str[sa[j]+s])break;

h[i]=s;

}

for(i=0;i<n;i++)height[rank[i]]=h[i];

preRMQ(height,n);

}

/*

LCP询问后缀数组sa[]中x和y的最长公共前缀，复杂度O(logn)

*/

intLCP(intx,inty){

if(x<y)returnRMQ(x+1,y);

elsereturnRMQ(y+1,x);

}

/**************************************/

intn,m;

intstr[N];

intsa[N];

intrank[N];

intheight[N];

voidprinta(inta[]){

inti;

for(i=0;a[i];i++)printf("%d",a[i]-1);

puts("");

}

intmain()

{

inti,j,k;

intans;

while(scanf("%d%d",&n,&m)!=EOF){

nday=n+1;

for(i=0;i<n;i++){

scanf("%d",&str[i]);str[i]++;

}

str[n]=0;

suffixArray(str,sa,rank);

preLCP(str,sa,rank,height);

/*

for(i=0;i<n;i++){

printf("%d-%d:",i,sa[i]);

printa(str+sa[i]);

}*/

ans=0;

for(i=0,j=m-1;j<=n;i++,j++){

k=LCP(i,j);

ans=MAX(ans,k);

}

printf("%d/n",ans);

}

return0;

}

（五）不相同的子串的个数（spoj694,spoj705）给定一个字符串，求不相同的子串的个数。算法分析：每个子串一定是某个后缀的前缀，那么原问题等价于求所有后缀之间的不相同的前缀的个数。如果所有的后缀按照suffix(sa[1]),suffix(sa[2]),suffix(sa[3]),……,suffix(sa)的顺序计算，不难发现，对于每一次新加进来的后缀suffix(sa[k]),它将产生n-sa[k]+1个新的前缀。但是其中有height[k]个是和前面的字符串的前缀是相同的。所以suffix(sa[k])将“贡献”出n-sa[k]+1-height[k]个不同的子串。累加后便是原问题的答案。这个做法的时间复杂度为O(n)。

/*

*Author:ZhaofaFang

*Createdtime:2013-04-21-21.19

*Language:C++

*/

#include<cstdio>

#include<cstdlib>

#include<sstream>

#include<iostream>

#include<cmath>

#include<cstring>

#include<algorithm>

#include<string>

#include<utility>

#include<vector>

#include<queue>

#include<map>

#include<set>

usingnamespacestd;

typedeflonglongll;

#defineDEBUG(x)cout<<#x<<':'<<x<<endl

#defineFOR(i,s,t)for(inti=(s);i<=(t);i++)

#defineFORD(i,s,t)for(inti=(s);i>=(t);i--)

#defineREP(i,n)FOR(i,0,n-1)

#defineREPD(i,n)FORD(i,n-1,0)

#definePIIpair<int,int>

#definePBpush_back

#defineMPmake_pair

#defineftfirst

#definesdsecond

#definelowbit(x)(x&(-x))

#defineINF(1<<30)

constintmaxn=1111;

chars[maxn];

intsa[maxn],t1[maxn],t2[maxn],c[maxn];

intrank[maxn],height[maxn];

voidgetHeight(intn){

intk=0;

for(inti=1;i<=n;i++)rank[sa[i]]=i;

for(inti=0;i<n;i++){

if(k)k--;

intj=sa[rank[i]-1];

while(s[i+k]==s[j+k])k++;

height[rank[i]]=k;

}

}

boolcmp(int*r,inta,intb,intl){

return(r[a]==r[b]&&r[a+l]==r[b+l]);

}

voidbuild_sa(intm,intn){

inti,*x=t1,*y=t2,k,p;

for(i=0;i<m;i++)c[i]=0;

for(i=0;i<n;i++)c[x[i]=s[i]]++;

for(i=1;i<m;i++)c[i]+=c[i-1];

for(i=n-1;i>=0;i--)sa[--c[x[i]]]=i;

for(k=1,p=0;p<n;m=p,k<<=1){

p=0;

for(i=n-k;i<n;i++)y[p++]=i;

for(i=0;i<n;i++)if(sa[i]>=k)y[p++]=sa[i]-k;

for(i=0;i<m;i++)c[i]=0;

for(i=0;i<n;i++)c[x[y[i]]]++;

for(i=1;i<m;i++)c[i]+=c[i-1];

for(i=n-1;i>=0;i--)sa[--c[x[y[i]]]]=y[i];

swap(x,y);

p=1;x[sa[0]]=0;

for(i=1;i<n;i++)

x[sa[i]]=cmp(y,sa[i-1],sa[i],k)?p-1:p++;

}

getHeight(n-1);

}

intsolve(intn){

intans=n-sa[1];

for(inti=2;i<=n;i++){

ans+=n-sa[i]-height[i];

}

returnans;

}

intmain(){

//freopen("in","r",stdin);

//freopen("out","w",stdout);

intT;

cin>>T;

while(T--){

scanf("%s",s);

intn=strlen(s);

build_sa(255,n+1);

printf("%d\n",solve(n));

}

return0;

}

（六）回文子串：如果将字符串L的某个子字符串R反过来写后和原来的字符串R一样，则称字符串R是字符串L的回文子串。例6：最长回文子串（ural1297）给定一个字符串，求最长回文子串。算法分析：穷举每一位，然后计算以这个字符为中心的最长回文子串。注意这里要分两种情况，一是回文子串的长度为奇数，二是长度为偶数。两种情况都可以转化为求一个后缀和一个反过来写的后缀的最长公共前缀。具体的做法是：将整个字符串反过来写在原字符串后面，中间用一个特殊的字符隔开。这样就把问题变为了求这个新的字符串的某两个后缀的最长公共前缀。如图6所示。这个做法的时间复杂度为O(nlogn)。如果RMQ问题用时间为O(n)的方法预处理，那么本题的时间复杂度可以降为O(n)。

#include<stdio.h>

#include<iostream>

#include<string.h>

#include<algorithm>

#defineMS(a,b)memset(a,b,sizeof(a))

usingnamespacestd;

constintmaxn=200010;

chars[maxn];

intw[maxn],wa[maxn],wb[maxn],wv[maxn],x[maxn],sa[maxn],Rank[maxn],height[maxn],n;

intcmp(int*r,inta,intb,intl)

{

returnr[a]==r[b]&&r[a+l]==r[b+l];

}

voidda(intn,intm)//n:L,m:kind

{

inti,j,p,*x=wa,*y=wb,*t;

for(i=0;i<m;i++)w[i]=0;

for(i=0;i<n;i++)w[x[i]=s[i]]++;

for(i=1;i<m;i++)w[i]+=w[i-1];

for(i=n-1;i>=0;i--)sa[--w[x[i]]]=i;

for(p=1,j=1;p<n;j*=2,m=p)

{

for(p=0,i=n-j;i<n;i++)y[p++]=i;

for(i=0;i<n;i++)if(sa[i]>=j)y[p++]=sa[i]-j;

for(i=0;i<m;i++)w[i]=0;

for(i=0;i<n;i++)w[wv[i]=x[y[i]]]++;

for(i=1;i<m;i++)w[i]+=w[i-1];

for(i=n-1;i>=0;i--)sa[--w[wv[i]]]=y[i];

for(t=x,x=y,y=t,p=1,i=1,x[sa[0]]=0;i<n;i++)

x[sa[i]]=cmp(y,sa[i-1],sa[i],j)?p-1:p++;

}

return;

}

voidcal(intn)

{

inti,j,k=0;

for(i=1;i<=n;i++)Rank[sa[i]]=i;

for(i=0;i<n;height[Rank[i++]]=k)

for(k?k--:0,j=sa[Rank[i]-1];s[i+k]==s[j+k];k++);

return;

}

intmain()

{

//freopen("F:\\in.txt","r",stdin);

intlen,l,ans;

while(~scanf("%s",s))

{

l=strlen(s);

chars1[maxn];

MS(s1,0);

strcpy(s1,s);

reverse(s1,s1+strlen(s1));

s[l]='#';

strncat(s,s1,l);

len=strlen(s);

da(len+1,'z'+1);//sastart0

cal(len);

ans=0;

//cout<<s<<endl;

for(inti=1;i<=len;i++)

{

//cout<<sa[i]<<''<<sa[i-1]<<''<<ans<<endl;

if(sa[i]<l&&sa[i-1]>l||sa[i]>l&&sa[i-1]<l)

ans=max(ans,height[i]);

}

printf("%d\n",ans);

MS(s,0);

}

return0;

}

(七)连续重复串：如果一个字符串L是由某个字符串S重复R次而得到的，则称L是一个连续重复串。R是这个字符串的重复次数。例7：连续重复子串(pku2406)给定一个字符串L，已知这个字符串是由某个字符串S重复R次而得到的，求R的最大值。算法分析：做法比较简单，穷举字符串S的长度k，然后判断是否满足。判断的时候，先看字符串L的长度能否被k整除，再看suffix(1)和suffix(k+1)的最长公共前缀是否等于n-k。在询问最长公共前缀的时候，suffix(1)是固定的，所以RMQ问题没有必要做所有的预处理，只需求出height数组中的每一个数到height[rank[1]]之间的最小值即可。整个做法的时间复杂度为O(n)。（八）重复次数最多的连续重复子串(spoj687,pku3693)给定一个字符串，求重复次数最多的连续重复子串。算法分析：先穷举长度L，然后求长度为L的子串最多能连续出现几次。首先连续出现1次是肯定可以的，所以这里只考虑至少2次的情况。假设在原字符串中连续出现2次，记这个子字符串为S，那么S肯定包括了字符r[0],r[L],r[L*2],r[L*3],……中的某相邻的两个。所以只须看字符r[L*i]和r[L*(i+1)]往前和往后各能匹配到多远，记这个总长度为K，那么这里连续出现了K/L+1次。最后看最大值是多少。如图7所示。穷举长度L的时间是n，每次计算的时间是n/L。所以整个做法的时间复杂度是O(n/1+n/2+n/3+……+n/n)=O(nlogn)。

//FileName:3693.cpp

//Author:Zlbing

//CreatedTime:2013年09月06日星期五21时05分32秒

#include<iostream>

#include<string>

#include<algorithm>

#include<cstdlib>

#include<cstdio>

#include<set>

#include<map>

#include<vector>

#include<cstring>

#include<stack>

#include<cmath>

#include<queue>

usingnamespacestd;

#defineCL(x,v);memset(x,v,sizeof(x));

#defineINF0x3f3f3f3f

#defineLLlonglong

#defineREP(i,r,n)for(inti=r;i<=n;i++)

#defineRREP(i,n,r)for(inti=n;i>=r;i--)

//rank从0开始

//sa从1开始,因为最后一个字符(最小的)排在第0位

//height从2开始,因为表示的是sa[i-1]和sa[i]

constintMAXN=220000;

intrank[MAXN],sa[MAXN],X[MAXN],Y[MAXN],height[MAXN];

chars[MAXN];

intbuc[MAXN];

voidcalheight(intn){

inti,j,k=0;

for(i=1;i<=n;i++)rank[sa[i]]=i;

for(i=0;i<n;height[rank[i++]]=k)

for(k?k--:0,j=sa[rank[i]-1];s[i+k]==s[j+k];k++);

}

boolcmp(int*r,inta,intb,intl){

return(r[a]==r[b]&&r[a+l]==r[b+l]);

}

voidsuffix(intn,intm=128){

inti,l,p,*x=X,*y=Y;

for(i=0;i<m;i++)buc[i]=0;

for(i=0;i<n;i++)buc[x[i]=s[i]]++;

for(i=1;i<m;i++)buc[i]+=buc[i-1];

for(i=n-1;i>=0;i--)sa[--buc[x[i]]]=i;

for(l=1,p=1;p<n;m=p,l*=2){

p=0;

for(i=n-l;i<n;i++)y[p++]=i;

for(i=0;i<n;i++)if(sa[i]>=l)y[p++]=sa[i]-l;

for(i=0;i<m;i++)buc[i]=0;

for(i=0;i<n;i++)buc[x[y[i]]]++;

for(i=1;i<m;i++)buc[i]+=buc[i-1];

for(i=n-1;i>=0;i--)sa[--buc[x[y[i]]]]=y[i];

for(swap(x,y),x[sa[0]]=0,i=1,p=1;i<n;i++)

x[sa[i]]=cmp(y,sa[i-1],sa[i],l)?p-1:p++;

}

calheight(n-1);//后缀数组关键是求出height,所以求sa的时候顺便把rank和height求出来

}

//当需要反复询问两个后缀的最长公共前缀时用到RMQ

intLog[MAXN];

intbest[20][MAXN];

voidinitRMQ(intn){//初始化RMQ

for(inti=1;i<=n;i++)best[0][i]=height[i];

for(inti=1;i<=Log[n];i++){

intlimit=n-(1<<i)+1;

for(intj=1;j<=limit;j++){

best[i][j]=min(best[i-1][j],best[i-1][j+(1<<i>>1)]);

}

}

}

intlcp(inta,intb){//询问a,b后缀的最长公共前缀

a=rank[a];b=rank[b];

if(a>b)swap(a,b);

a++;

intt=Log[b-a+1];

returnmin(best[t][a],best[t][b-(1<<t)+1]);

}

intmain(){

//预处理每个数字的Log值,常数优化,用于RMQ

Log[0]=-1;

for(inti=1;i<MAXN;i++){

Log[i]=(i&(i-1))?Log[i-1]:Log[i-1]+1;

}

intcas=0;

//*******************************************

//n为数组长度,下标0开始

//将初始数据,保存在s里,并且保证每个数字都比0大

//m=max{s[i]}+1

//一般情况下大多是字符操作,所以128足够了

//*******************************************

while(~scanf("%s",s))

{

if(s[0]=='#')break;

intn=strlen(s);

s[n]=0;

suffix(n+1);

initRMQ(n);

intmaxx=0;

intlen=0;

intpos=0;

for(inti=1;i<=n/2;i++)

{

for(intj=0;j+i<n;j+=i)

{

if(s[j]!=s[j+i])continue;

intk=lcp(j,j+i);

inttot=k/i+1;

intt=i-(k%i);

intp=j;

intcnt=0;

if(t&&t<i)

{

for(intm=j-1;m>j-i&&s[m]==s[m+i]&&m>=0;m--)

{

cnt++;

if(cnt==t)

{

tot++;

p=m;

}

elseif(rank[p]>rank[m])

{

p=m;

}

}

}

if(tot>maxx)

{

maxx=tot;

pos=p;

len=maxx*i;

}

elseif(tot==maxx)

{

if(rank[p]<rank[pos])

{

pos=p;

len=maxx*i;

}

}

}

}

printf("Case%d:",++cas);

if(maxx<2)

{

charch='z';

for(inti=0;i<n;i++)

if(s[i]<ch)

ch=s[i];

printf("%c\n",ch);

continue;

}

for(inti=pos;i<pos+len;i++)

printf("%c",s[i]);

printf("\n");

}

return0;

}

（九）公共子串:如果字符串L同时出现在字符串A和字符串B中，则称字符串L是字符串A和字符串B的公共子串。例9：最长公共子串(pku2774,ural1517)给定两个字符串A和B，求最长公共子串。算法分析:字符串的任何一个子串都是这个字符串的某个后缀的前缀。求A和B的最长公共子串等价于求A的后缀和B的后缀的最长公共前缀的最大值。如果枚举A和B的所有的后缀，那么这样做显然效率低下。由于要计算A的后缀和B的后缀的最长公共前缀，所以先将第二个字符串写在第一个字符串后面，中间用一个没有出现过的字符隔开，再求这个新的字符串的后缀数组。观察一下，看看能不能从这个新的字符串的后缀数组中找到一些规律。以A=“aaaba”，B=“abaa”为例，如图8所示。那么是不是所有的height值中的最大值就是答案呢？不一定！有可能这两个后缀是在同一个字符串中的，所以实际上只有当suffix(sa[i-1])和suffix(sa[i])不是同一个字符串中的两个后缀时，height[i]才是满足条件的。而这其中的最大值就是答案。记字符串A和字符串B的长度分别为|A|和|B|。求新的字符串的后缀数组和height数组的时间是O(|A|+|B|)，然后求排名相邻但原来不在同一个字符串中的两个后缀的height值的最大值，时间也是O(|A|+|B|)，所以整个做法的时间复杂度为O(|A|+|B|)。时间复杂度已经取到下限，由此看出，这是一个非常优秀的算法。

子串的个数

例10:长度不小于k的公共子串的个数(pku3415)给定两个字符串A和B，求长度不小于k的公共子串的个数（可以相同）。样例1:A=“xx”，B=“xx”，k=1，长度不小于k的公共子串的个数是5。样例2:A=“aababaa”，B=“abaabaa”，k=2，长度不小于k的公共子串的个数是22。算法分析:基本思路是计算A的所有后缀和B的所有后缀之间的最长公共前缀的长度，把最长公共前缀长度不小于k的部分全部加起来。先将两个字符串连起来，中间用一个没有出现过的字符隔开。按height值分组后，接下来的工作便是快速的统计每组中后缀之间的最长公共前缀之和。扫描一遍，每遇到一个B的后缀就统计与前面的A的后缀能产生多少个长度不小于k的公共子串，这里A的后缀需要用一个单调的栈来高效的维护。然后对A也这样做一次。具体的细节留给读者思考。

#include<stdio.h>

#include<iostream>

#include<string.h>

#include<algorithm>

#defineMS(a,b)memset(a,b,sizeof(a))

usingnamespacestd;

constintmaxn=200010;

chars[maxn];

intw[maxn],wa[maxn],wb[maxn],wv[maxn],x[maxn],sa[maxn],Rank[maxn],height[maxn],n;

intcmp(int*r,inta,intb,intl)

{

returnr[a]==r[b]&&r[a+l]==r[b+l];

}

voidda(intn,intm)//n:L,m:kind

{

inti,j,p,*x=wa,*y=wb,*t;

for(i=0;i<m;i++)w[i]=0;

for(i=0;i<n;i++)w[x[i]=s[i]]++;

for(i=1;i<m;i++)w[i]+=w[i-1];

for(i=n-1;i>=0;i--)sa[--w[x[i]]]=i;

for(p=1,j=1;p<n;j*=2,m=p)

{

for(p=0,i=n-j;i<n;i++)y[p++]=i;

for(i=0;i<n;i++)if(sa[i]>=j)y[p++]=sa[i]-j;

for(i=0;i<m;i++)w[i]=0;

for(i=0;i<n;i++)w[wv[i]=x[y[i]]]++;

for(i=1;i<m;i++)w[i]+=w[i-1];

for(i=n-1;i>=0;i--)sa[--w[wv[i]]]=y[i];

for(t=x,x=y,y=t,p=1,i=1,x[sa[0]]=0;i<n;i++)

x[sa[i]]=cmp(y,sa[i-1],sa[i],j)?p-1:p++;

}

return;

}

voidcal(intn)

{

inti,j,k=0;

for(i=1;i<=n;i++)Rank[sa[i]]=i;

for(i=0;i<n;height[Rank[i++]]=k)

for(k?k--:0,j=sa[Rank[i]-1];s[i+k]==s[j+k];k++);

return;

}

intmain()

{

//freopen("F:\\in.txt","r",stdin);

intlen,l,ans,t,m,r,i,ll,rr;

scanf("%d",&t);

while(t--)

{

scanf("%s%d",s,&m);

len=strlen(s);

da(len+1,'z'+1);//sastart0

cal(len);

while(m--){

scanf("%d%d",&l,&r);

intd=r-l+1;

ans=0;

ll=Rank[l-1];

rr=Rank[r-1];

if(ll>rr)swap(rr,ll);

intflag=0;

for(i=0;i<=len;i++){

ans+=d-sa[i]-height[i];

//cout<<i<<''<<sa[i]<<''<<l<<''<<r<<''<<height[i]<<endl;

}

printf("%d\n",ans);

}

}

return0;

}

2.4多个字符串的相关问题

这类问题的一个常用做法是，先将所有的字符串连接起来，然后求后缀数组和height数组，再利用height数组进行求解。这中间可能需要二分答案。例11:不小于k个字符串中的最长子串(pku3294)给定n个字符串，求出现在不小于k个字符串中的最长子串。算法分析:将n个字符串连起来，中间用不相同的且没有出现在字符串中的字符隔开，求后缀数组。然后二分答案，用和例3同样的方法将后缀分成若干组，判断每组的后缀是否出现在不小于k个的原串中。这个做法的时间复杂度为O(nlogn)。例12:每个字符串至少出现两次且不重叠的最长子串(spoj220)给定n个字符串，求在每个字符串中至少出现两次且不重叠的最长子串。算法分析:做法和上题大同小异，也是先将n个字符串连起来，中间用不相同的且没有出现在字符串中的字符隔开，求后缀数组。然后二分答案，再将后缀分组。判断的时候，要看是否有一组后缀在每个原来的字符串中至少出现两次，并且在每个原来的字符串中，后缀的起始位置的最大值与最小值之差是否不小于当前答案（判断能否做到不重叠，如果题目中没有不重叠的要求，那么不用做此判断）。这个做法的时间复杂度为O(nlogn)。例13:出现或反转后出现在每个字符串中的最长子串(PKU3294)给定n个字符串，求出现或反转后出现在每个字符串中的最长子串。算法分析:这题不同的地方在于要判断是否在反转后的字符串中出现。其实这并没有加大题目的难度。只需要先将每个字符串都反过来写一遍，中间用一个互不相同的且没有出现在字符串中的字符隔开，再将n个字符串全部连起来，中间也是用一个互不相同的且没有出现在字符串中的字符隔开，求后缀数组。然后二分答案，再将后缀分组。判断的时候，要看是否有一组后缀在每个原来的字符串或反转后的字符串中出现。这个做法的时间复杂度为O(nlogn)。子串出现两个以上的个数：

#include<stdio.h>

#include<iostream>

#include<cstring>

#include<map>

#defineMS(a,b)memset(a,b,sizeof(a))

#defineINF1<<29

usingnamespacestd;

constintmaxn=200010;

strings;

intw[maxn],wa[maxn],wb[maxn],wv[maxn],x[maxn],sa[maxn],Rank[maxn],height[maxn],n;

intcmp(int*r,inta,intb,intl)

{

returnr[a]==r[b]&&r[a+l]==r[b+l];

}

voidda(intn,intm)//n:L,m:kind

{

inti,j,p,*x=wa,*y=wb,*t;

for(i=0;i<m;i++)w[i]=0;

for(i=0;i<n;i++)w[x[i]=s[i]]++;

for(i=1;i<m;i++)w[i]+=w[i-1];

for(i=n-1;i>=0;i--)sa[--w[x[i]]]=i;

for(p=1,j=1;p<n;j*=2,m=p)

{

for(p=0,i=n-j;i<n;i++)y[p++]=i;

for(i=0;i<n;i++)if(sa[i]>=j)y[p++]=sa[i]-j;

for(i=0;i<m;i++)w[i]=0;

for(i=0;i<n;i++)w[wv[i]=x[y[i]]]++;

for(i=1;i<m;i++)w[i]+=w[i-1];

for(i=n-1;i>=0;i--)sa[--w[wv[i]]]=y[i];

for(t=x,x=y,y=t,p=1,i=1,x[sa[0]]=0;i<n;i++)

x[sa[i]]=cmp(y,sa[i-1],sa[i],j)?p-1:p++;

}

return;

}

voidcal(intn)

{

inti,j,k=0;

for(i=1;i<=n;i++)Rank[sa[i]]=i;

for(i=0;i<n;height[Rank[i++]]=k)

for(k?k--:0,j=sa[Rank[i]-1];s[i+k]==s[j+k];k++);

return;

}

intsolve(inti,intn)

{

intans=0,max1=-1,min1=INF,j;

for(j=2;j<=n;j++)

{

if(height[j]>=i)//由于height[i]是rank[i]和rank[i]-1的最长公共前缀，rank是排序了，所以

{//如果连续if而没有else，重复子串也不会变

max1=max(sa[j-1],max(max1,sa[j]));

min1=min(sa[j-1],min(min1,sa[j]));

}

else

{

if(min1!=INF&&max1!=-1&&max1-min1>=i)//判断长度为i的重复子串是否重叠

ans++;

max1=-1;

min1=INF;

}

}

if(min1!=INF&&max1!=-1&&max1-min1>=i)

ans++;

returnans;

}

intmain()

{

//freopen("F:\\in.txt","r",stdin);

intl,j,k;

while(cin>>s)

{

if(s=="#")break;

l=s.size();

s[l]='#';

da(l+1,'z'+1);//sastart0

cal(l);

__int64ans=0;

for(inti=1;i<=l/2;i++){

ans+=solve(i,l);

}

printf("%I64d\n",ans);

}

return0;

}