后缀数组--经典题型

后缀例题

转自--后缀数组---处理字符串的有力工具 

例1 ：最长公共前缀

问题描述：给定一个字符串，询问某两个后缀的最长公共前缀。

算法分析：问题可以转化为：height数组的区间最小值。所以加上一个 RMQ+倍增算法模板。可以O(1)查询。

题目+代码：略。

例2：可重叠最长重复子串

问题描述：给定一个字符串，求最长重复子串，这两个子串可以重叠。

算法分析：就是在height数组中找一个最大值。为什么这样，略。

题目+代码：略。

例3：不可重叠最长重复子串

问题描述：给定一个字符串，求最长重复子串，这两个子串不能重叠。

算法分析：枚举长度,进行判断,枚举时长度可以二分。原问题转为：判断当长度为K问是否存在两个及以上的字符串并且没有重叠？

解决这个问题，需要理解分组。将后缀排序，相邻两个的最长公共前缀如果大于等于K，那么一定存在长度为K的字符串是相同的。所以：排序后height数组大于等于K的连续个数+1 代表相同的字符串有多少个。

最长的不重叠字符串，按heigt<k进行分组,分组之后每组中才会存在长度大于K的字符串。在每组中,判断有SA的最大最小是否大于等于K。为什么是这样，下面有解释：

某两个最大不重叠长度=min（l1-l2，height），当我们按照height<K的分组那么每组中height都是大于等于K，所以每组中的SA极差就是最长的长度。

题目+代码：https://vjudge.net/problem/POJ-1743 

 

#include <cstdio>
#include <cstring>
#include <cctype>
#include <cmath>
#include <set>
#include <map>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <vector>
#include <iostream>
#include <algorithm>
#include <stdlib.h>

using namespace std;
typedef long long LL;
const int INF=2e9+1e8;
const int MOD=1e9+7;
const int MAXSIZE=1e6+5;
const double eps=0.0000000001;
void fre()
{
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
}
#define memst(a,b) memset(a,b,sizeof(a))
#define fr(i,a,n) for(int i=a;i<n;i++)

int ranks[MAXSIZE],SA[MAXSIZE],height[MAXSIZE];
int wa[MAXSIZE],wb[MAXSIZE],wvarr[MAXSIZE],wsarr[MAXSIZE];

int cmp(int *r,int a,int b,int l)
{
    return r[a]==r[b]&&r[a+l]==r[b+l];
}
void da(int *r,int *sa,int n,int m)
{
    int i,j,p,*x=wa,*y=wb,*t;
    for(i=0; i<m; i++) wsarr[i]=0;
    for(i=0; i<n; i++) wsarr[x[i]=r[i]]++;
    for(i=1; i<m; i++) wsarr[i]+=wsarr[i-1];
    for(i=n-1; i>=0; i--) sa[--wsarr[x[i]]]=i;
    for(j=1, p=1; p<n; j<<=1,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++) wvarr[i]=x[y[i]];
        for(i=0; i<m; i++) wsarr[i]=0;
        for(i=0; i<n; i++) wsarr[wvarr[i]]++;
        for(i=1; i<m; i++) wsarr[i]+=wsarr[i-1];
        for(i=n-1; i>=0; i--) sa[--wsarr[wvarr[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++;
    }
}
void calheight(int *r,int *sa,int n)
{
    int i,j,k=0;
    for(i=1; i<=n; i++) ranks[sa[i]]=i;
    for(i=0; i<n; height[ranks[i++]]=k)
        for(k?k--:0,j=sa[ranks[i]-1]; r[i+k]==r[j+k]; k++);
    return;
}

bool Judge(int n,int k)
{
    int mi,ma;
    mi=ma=SA[1];
    for(int i=2; i<=n; i++)
    {
        if(height[i]>=k)
        {
            mi=min(mi,SA[i]);
            ma=max(ma,SA[i]);
            continue;
        }
        if(ma-mi>=k) return true;
        mi=ma=SA[i];
    }
    return false;
}


int a[MAXSIZE];
int main()
{
    int n;
    while(scanf("%d",&n)&&n)
    {
        for(int i=0; i<n; i++) scanf("%d",&a[i]);
        for(int i=0; i<n-1; i++) a[i]=a[i+1]-a[i]+100;
        a[n-1]=0;
        da(a,SA,n,200);
        calheight(a,SA,n-1);
        int l,r,mid,ans=0;
        l=1,r=n-1;
        while(l<=r)
        {
            mid=(l+r)>>1;
            if(Judge(n,mid)) ans=mid,l=mid+1;
            else r=mid-1;
        }
        ans++;
        if(ans<5) printf("0
");
        else printf("%d
",ans);
    }
    return 0;
}

/**************************************************/
/**             Copyright Notice                 **/
/**  writer: wurong                              **/
/**  school: nyist                               **/
/**  blog  : http://blog.csdn.net/wr_technology  **/
/**************************************************/

例4：可重复的K次最长重复子串

问题描述：给定一个字符串，球出现至少K次的最长字符串长度，字符串可以重叠。

算法分析：有了以上题目经验，这个题目就很简单了，排好序的height数组，分组之后连续大于某个数的个数+1就是重复子串个数，保证子串个数大于K就OK了。

题目+代码：https://vjudge.net/problem/POJ-3261

 

#include <cstdio>
#include <cstring>
#include <cctype>
#include <cmath>
#include <set>
#include <map>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <vector>
#include <iostream>
#include <algorithm>
#include <stdlib.h>

using namespace std;
typedef long long LL;
const int INF=2e9+1e8;
const int MOD=1e9+7;
const int MAXSIZE=1e6+5;
const double eps=0.0000000001;
void fre()
{
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
}
#define memst(a,b) memset(a,b,sizeof(a))
#define fr(i,a,n) for(int i=a;i<n;i++)

int ranks[MAXSIZE],SA[MAXSIZE],height[MAXSIZE];
int wa[MAXSIZE],wb[MAXSIZE],wvarr[MAXSIZE],wsarr[MAXSIZE];

int cmp(int *r,int a,int b,int l)
{
    return r[a]==r[b]&&r[a+l]==r[b+l];
}
void da(int *r,int *sa,int n,int m)
{
    int i,j,p,*x=wa,*y=wb,*t;
    for(i=0; i<m; i++) wsarr[i]=0;
    for(i=0; i<n; i++) wsarr[x[i]=r[i]]++;
    for(i=1; i<m; i++) wsarr[i]+=wsarr[i-1];
    for(i=n-1; i>=0; i--) sa[--wsarr[x[i]]]=i;
    for(j=1, p=1; p<n; j<<=1,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++) wvarr[i]=x[y[i]];
        for(i=0; i<m; i++) wsarr[i]=0;
        for(i=0; i<n; i++) wsarr[wvarr[i]]++;
        for(i=1; i<m; i++) wsarr[i]+=wsarr[i-1];
        for(i=n-1; i>=0; i--) sa[--wsarr[wvarr[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++;
    }
}
void calheight(int *r,int *sa,int n)
{
    int i,j,k=0;
    for(i=1; i<=n; i++) ranks[sa[i]]=i;
    for(i=0; i<n; height[ranks[i++]]=k)
        for(k?k--:0,j=sa[ranks[i]-1]; r[i+k]==r[j+k]; k++);
    return;
}

bool judge(int n,int k,int val)
{
    int cnt=1;
    for(int i=2; i<=n; i++)
    {
        if(height[i]>=val) cnt++;
        else cnt=1;
        if(cnt>=k) return 1;
    }
    return 0;
}

int a[MAXSIZE];
int main(int argc,char *argv[])
{
    int n,k;
    while(scanf("%d%d",&n,&k)!=EOF)
    {
        for(int i=0; i<n; i++)
            scanf("%d",&a[i]);
        a[n]=0;
        da(a,SA,n+1,20000+1);
        calheight(a,SA,n);
        int L=1,R=n;
        int mid,ans=0;
        while(L<=R)
        {
            mid=(L+R)>>1;
            if(judge(n,k,mid)) ans=mid,L=mid+1;
            else R=mid-1;
        }
        printf("%d
",ans);
    }
    return 0;
}

/**************************************************/
/**             Copyright Notice                 **/
/**  writer: wurong                              **/
/**  school: nyist                               **/
/**  blog  : http://blog.csdn.net/wr_technology  **/
/**************************************************/

例5：不相同子串个数？

题目描述：给定一个字符串，问其中有多少个不相同的子字符串？

本题目传送门

例6：最长回文子串。

题目描述：给定一个字符串。求最长回文子串，一般求最长回文子串的长度。

算法分析：法一：Manacher

方法二： 穷举每一位， 然后计算以这个字符为中心的最长回文子串。 注意这里要分两种情况， 一是回文子串的长度为奇数， 二是长度为偶数。 两 种情况都可以转化 为 求一个后缀和一个反过来写的后缀的最长公共前缀。 具体的做法是： 将 整个字 符 串反过来写在原字符串后面， 中间用一个特殊的字符隔开。 这 样就把问题变为 了 求这个新的字符串的某两个后缀的最长公共前缀。

题目+代码：

https://cn.vjudge.net/problem/HDU-3068

后缀数组法：代码省略，就是求height数组的最大值。

Manacher法：点击查看代码

https://vjudge.net/problem/URAL-1297

Manacher算法：因为是求最长回文子串中首先出现的在找最大p[]数组时记录第一个即可。代码省略。

后缀数组法： 只需要记录height数组中最大的而下表最小的，即可。

 

#include <cstdio>
#include <cstring>
#include <cctype>
#include <cmath>
#include <set>
#include <map>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <string>
#include <vector>
#include <iostream>
#include <algorithm>
#include <stdlib.h>
#include <time.h>

using namespace std;
typedef long long LL;
const int INF=2e9+1e8;
const int MOD=1e9+7;
const int MAXSIZE=1e6+5;
const double eps=0.0000000001;
void fre()
{
    freopen("in.txt","r",stdin);
    freopen("out.txt","w",stdout);
}
#define memst(a,b) memset(a,b,sizeof(a))
#define fr(i,a,n) for(int i=a;i<n;i++)
/**
求第一个出现的最长回文子串。
height数组最大的是最长回文子串的长度；

*/


int Rank[MAXSIZE],SA[MAXSIZE],height[MAXSIZE];
int wa[MAXSIZE],wb[MAXSIZE],wv[MAXSIZE],wss[MAXSIZE];
int cmp(int *r,int a,int b,int l)
{
    return r[a]==r[b]&&r[a+l]==r[b+l];
}
void da(int *r,int *sa,int n,int m)
{
    int i,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<<=1,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;
}
void calheight(int *r,int *sa,int n)
{
    int i,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;
}

char str[2000+10];
int rs[MAXSIZE];
int main()
{
    while(scanf("%s",str)!=EOF)
    {
        int len=strlen(str);
        for(int i=0;i<len;i++) rs[i]=(int)str[i];
        rs[len]=1;
        int n=2*len+1;
        for(int i=len+1,j=len-1;j>=0;j--,i++) rs[i]=(int)str[j];
        rs[n]=0;
        da(rs,SA,n+1,128);
        calheight(rs,SA,n);
        int pos=0,maxlen=0;
        for(int i=2;i<=n;i++)
            if(height[i]>maxlen)
            {
                pos=min(SA[i],SA[i-1]);
                maxlen=height[i];
            }
            else if(height[i]==maxlen)
                pos=min(pos,min(SA[i],SA[i-1]));
      //  printf("maxlen=%d  start=%d
",maxlen,pos);
        for(int i=pos;i<pos+maxlen;i++)
            printf("%c",str[i]);
        printf("
");
    }
    return 0;
}


/**************************************************/
/**             Copyright Notice                 **/
/**  writer: wurong                              **/
/**  school: nyist                               **/
/**  blog  : http://blog.csdn.net/wr_technology  **/
/**************************************************/

   

例7：连续重复子串  

https://cn.vjudge.net/problem/POJ-2406

题目描述：给定一个字符串L，已知这个字符串是由某个字符串S重复R次而得到的，求R的最大值。

算法分析：穷举法；具体看代码注释。

代码：写太多的，然后就不太想要写了。借鉴别人代码！

还有一种方法就是 KMP 算法：Next数组就是可以回滚到字符串的某一位，判断末尾的Next数组的值。详见这里

//代码来源: http://blog.csdn.net/superxtong/article/details/52082133

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<vector>
#include<algorithm>
#define F(x) ((x)/3+((x)%3==1?0:tb))
#define G(x) ((x)<tb?(x)*3+1:((x)-tb)*3+2)
using namespace std;
const int maxn = int(3e6)+10;
const int N = maxn;
int wa[maxn],wb[maxn],wv[maxn],ws[maxn];
int RANK[N],height[N],rm[N],sa[N];
char a[N];
int b[N];
int c0(int *r,int a,int b)
{
    return r[a]==r[b]&&r[a+1]==r[b+1]&&r[a+2]==r[b+2];
}
int c12(int k,int *r,int a,int b)
{
    if(k==2) return r[a]<r[b]||r[a]==r[b]&&c12(1,r,a+1,b+1);
    else return r[a]<r[b]||r[a]==r[b]&&wv[a+1]<wv[b+1];
}
void sort(int *r,int *a,int *b,int n,int m)
{
    int i;
    for(i=0;i<n;i++) wv[i]=r[a[i]];
    for(i=0;i<m;i++) ws[i]=0;
    for(i=0;i<n;i++) ws[wv[i]]++;
    for(i=1;i<m;i++) ws[i]+=ws[i-1];
    for(i=n-1;i>=0;i--) b[--ws[wv[i]]]=a[i];
    return;
}
void dc3(int *r,int *sa,int n,int m) //涵义与DA 相同
{
    int i,j,*san=sa+n,ta=0,tb=(n+1)/3,tbc=0,p;
    int *rn=r+n;
    r[n]=r[n+1]=0;
    for(i=0;i<n;i++) if(i%3!=0) wa[tbc++]=i;
    sort(r+2,wa,wb,tbc,m);
    sort(r+1,wb,wa,tbc,m);
    sort(r,wa,wb,tbc,m);
    for(p=1,rn[F(wb[0])]=0,i=1;i<tbc;i++)
        rn[F(wb[i])]=c0(r,wb[i-1],wb[i])?p-1:p++;
    if(p<tbc) dc3(rn,san,tbc,p);
    else for(i=0;i<tbc;i++) san[rn[i]]=i;
    for(i=0;i<tbc;i++) if(san[i]<tb) wb[ta++]=san[i]*3;
    if(n%3==1) wb[ta++]=n-1;
    sort(r,wb,wa,ta,m);
    for(i=0;i<tbc;i++) wv[wb[i]=G(san[i])]=i;
    for(i=0,j=0,p=0;i<ta && j<tbc;p++)
        sa[p]=c12(wb[j]%3,r,wa[i],wb[j])?wa[i++]:wb[j++];
    for(;i<ta;p++) sa[p]=wa[i++];
    for(;j<tbc;p++) sa[p]=wb[j++];
    return;
}
void calheight(int *r,int *sa,int n)
{   // 此处N为实际长度
    int i,j,k=0;
    // height[]的合法范围为 1-N, 其中0是结尾加入的字符
    for(i=1;i<=n;i++)
        RANK[sa[i]]=i;
    // 根据SA求RANK
    for(i=0;i<n; height[RANK[i++]] = k )
        // 定义：h[i] = height[ RANK[i] ]
        for(k?k--:0,j=sa[RANK[i]-1];
            r[i+k]==r[j+k]; k++);
    //根据 h[i] >= h[i-1]-1 来优化计算height过程
}
void RMQ(int n)
{
    int k = RANK[1];
    rm[k] = N;
    for(int i=k-1;i>=0;i--)
    {
        rm[i]=min(rm[i+1],height[i+1]);
    }
    for(int i=k+1;i<=n;i++)
    {
        rm[i]=min(rm[i-1],height[i]);
    }
}
void solve(int le)
{
    for(int i=1;i<=le;i++)//枚举长度
    {
        if(le%i!=0)//不能整除的话，一定不能构成循环节。
            continue;
        if(RANK[i]+1!=RANK[0])
        //rank数组必须要相邻才能构成循环节。
        {
            continue;
        }
        if(height[RANK[0]]!=le-i)
        //若第一个和第二个的最长公共前缀不符合条件。
            continue;
        printf("%d
",le/i);
        return ;
    }
    printf("1
");
    return ;
}
long long nxt[N];
int main (void)
{
    while(~scanf("%s",a))
    {
        if(a[0]=='.')
            break;
        int le=strlen(a);
        for(int i=0;i<le;i++)
        {
            b[i]=a[i]-'a'+'0';
        }
        dc3(b,sa,le+1,200);
        calheight(b,sa,le);
        RMQ(le);
        solve(le);
    }
    return 0;
}

例8：重复次数最多的连续重复子串。

题目描述：给定一个字符串，求重复次数最多的子字符串。在给定字符串中找一个子串,它的重复次数最多的子字符串。

算法分析：

持续更新中••••••