后缀数组练习题（转）

最新推荐文章于 2022-11-23 16:04:09 发布
最新推荐文章于 2022-11-23 16:04:09 发布
阅读量1.1k 收藏
点赞数
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/just_water/article/details/9673057
版权
原文：http://hi.baidu.com/lewutian/blog/item/4d098138d29c34f9b311c725.html


接下来逐步A掉里面的题。

贴个DC3的模版。

/****后缀数组模版****/
#define F(x)((x)/3+((x)%3==1?0:tb)) //F(x)求出原字符串的suffix(x)在新的字符串中的起始位置
#define G(x)((x)<tb?(x)*3+1:((x)-tb)*3+2) //G(x)是计算新字符串的suffix(x)在原字符串中的位置，和F(x)为互逆运算
int wa[N],wb[N],wv[N],WS[N];
int sa[N*3] ;
int rank1[N],height[N];
int r[N*3];

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;
}

//注意点：为了方便下面的递归处理，r数组和sa数组的大小都要是3*n
void dc3(int *r,int *sa,int n,int m) { //rn数组保存的是递归处理的新字符串，san数组是新字符串的sa
    int i , j , *rn = r+n , *san = sa+n , ta = 0 ,tb = (n+1)/3 , tbc = 0 , p;
    r[n] = r[n+1] = 0;
    for(i=0; i<n; i++) {
        if(i%3!=0)
            wa[tbc++]=i; //tbc表示起始位置模3为1或2的后缀个数
    }
    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;
    }
//对所有起始位置模3等于0的后缀排序
    for(i=0; i<tbc; i++) {
        if(san[i]<tb)
            wb[ta++]=san[i]*3;
    }
    if(n%3==1)  //n%3==1，要特殊处理suffix(n-1)
        wb[ta++]=n-1;
    sort(r,wb,wa,ta,m);
    for(i=0; i<tbc; i++)
        wv[wb[i]=G(san[i])]=i;
//合并所有后缀的排序结果，保存在sa数组中
    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;
}

//height[i]=suffix(sa[i-1])和suffix(sa[i])的最长公共前缀，也就是排名相邻的两个后缀的最长公共前缀
void calheight(int *r,int *sa,int n) {
    int i,j,k=0;
    for(i=1; i<=n; i++)
        rank1[sa[i]]=i;
    for(i=0; i<n; height[rank1[i++]]=k)
        for(k?k--:0,j=sa[rank1[i]-1]; r[i+k]==r[j+k]; k++);
}



后缀数组经典思想：多串合并+二分答案+最优性--->可行性


例 1 ：最长公共前缀
给定一个字符串，询问某两个后缀的最长公共前缀。 // 直接套用，ans=min( height[ i ] )+rmq k<i<=j


例 2 ：可重叠最长重复子串
给定一个字符串，求最长重复子串，这两个子串可以重叠。 // ans=max( hegiht[ i ] ) 0<=i<len


例 3 ：不可重叠最长重复子串（ pku1743 ）
给定一个字符串，求最长重复子串，这两个子串不能重叠。 // 二分转化为判定性问题 
//POJ 1743
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstring>
#include <queue>
#include <set>
#include <vector>
#include <stack>
#include <map>
#include <iomanip>
#define PI acos(-1.0)
#define Max 2505
#define inf 1<<28
#define LL(x) ( x << 1 )
#define RR(x) ( x << 1 | 1 )
#define REP(i,s,t) for( int i = ( s ) ; i <= ( t ) ; ++ i )
#define ll long long
#define mem(a,b) memset(a,b,sizeof(a))
#define mp(a,b) make_pair(a,b)
#define PII pair<int,int>
using namespace std;
#define N 20005
/****后缀数组模版****/
#define F(x)((x)/3+((x)%3==1?0:tb)) //F(x)求出原字符串的suffix(x)在新的字符串中的起始位置
#define G(x)((x)<tb?(x)*3+1:((x)-tb)*3+2) //G(x)是计算新字符串的suffix(x)在原字符串中的位置，和F(x)为互逆运算
int wa[N],wb[N],wv[N],WS[N];
int sa[N*3] ;
int rank1[N],height[N];
int r[N*3];

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;
}

//注意点：为了方便下面的递归处理，r数组和sa数组的大小都要是3*n
void dc3(int *r,int *sa,int n,int m) { //rn数组保存的是递归处理的新字符串，san数组是新字符串的sa
    int i , j , *rn = r+n , *san = sa+n , ta = 0 ,tb = (n+1)/3 , tbc = 0 , p;
    r[n] = r[n+1] = 0;
    for(i=0; i<n; i++) {
        if(i%3!=0)
            wa[tbc++]=i; //tbc表示起始位置模3为1或2的后缀个数
    }
    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;
    }
//对所有起始位置模3等于0的后缀排序
    for(i=0; i<tbc; i++) {
        if(san[i]<tb)
            wb[ta++]=san[i]*3;
    }
    if(n%3==1)  //n%3==1，要特殊处理suffix(n-1)
        wb[ta++]=n-1;
    sort(r,wb,wa,ta,m);
    for(i=0; i<tbc; i++)
        wv[wb[i]=G(san[i])]=i;
//合并所有后缀的排序结果，保存在sa数组中
    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;
}

//height[i]=suffix(sa[i-1])和suffix(sa[i])的最长公共前缀，也就是排名相邻的两个后缀的最长公共前缀
void calheight(int *r,int *sa,int n) {
    int i,j,k=0;
    for(i=1; i<=n; i++)
        rank1[sa[i]]=i;
    for(i=0; i<n; height[rank1[i++]]=k)
        for(k?k--:0,j=sa[rank1[i]-1]; r[i+k]==r[j+k]; k++);
}
int solve(int n) {
    int i,sum=0;
    for(i=1; i<=n; i++) {
        sum += n - sa[i] - height[i] ;
    }

    return sum;
}
/****以上模版****/

int a[N] ;
bool check(int *sa , int n , int mid) {
    int mx = sa[1] ;
    int mn = sa[1] ;
    for (int i = 2 ; i <= n ; i ++ ) {
        if(height[i] < mid) {
            mx = sa[i] ;
            mn = sa[i] ;
        } else {
            mx = max(sa[i] ,mx) ;
            mn = min(sa[i] ,mn) ;
            if(mx - mn >= mid)return 1 ;
        }
    }
    return 0 ;
}
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 ++ )r[i] = a[i + 1] - a[i] + 100 ;
        r[n - 1] = 0 ;
        n -- ;
        dc3(r ,sa ,n + 1 , 200) ;
        calheight(r , sa ,n) ;
        int r = n , l = 1 ;
        int ans = 0 ;
        while(r >= l) {
            int mid = l + r >> 1 ;
            if(check(sa , n , mid)) {
                l = mid + 1 ;
                ans = max(ans ,mid) ;
            } else r = mid - 1 ;
        }
        if(ans < 4)puts("0") ;
        else printf("%d\n",ans + 1) ;
    }
    return 0 ;
}



例 4 ：可重叠的 k 次最长重复子串（ pku3261 ）
给定一个字符串，求至少出现 k 次的最长重复子串，这 k 个子串可以重叠。 // 同上，也是二分 
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstring>
#include <queue>
#include <set>
#include <vector>
#include <stack>
#include <map>
#include <iomanip>
#define PI acos(-1.0)
#define Max 2505
#define inf 1<<28
#define LL(x) ( x << 1 )
#define RR(x) ( x << 1 | 1 )
#define REP(i,s,t) for( int i = ( s ) ; i <= ( t ) ; ++ i )
#define ll long long
#define mem(a,b) memset(a,b,sizeof(a))
#define mp(a,b) make_pair(a,b)
#define PII pair<int,int>
using namespace std;
#define N 20005
/****后缀数组模版****/
#define F(x)((x)/3+((x)%3==1?0:tb)) //F(x)求出原字符串的suffix(x)在新的字符串中的起始位置
#define G(x)((x)<tb?(x)*3+1:((x)-tb)*3+2) //G(x)是计算新字符串的suffix(x)在原字符串中的位置，和F(x)为互逆运算
int wa[N],wb[N],wv[N],WS[N];
int sa[N*3] ;
int rank1[N],height[N];
int r[N*3];

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;
}

//注意点：为了方便下面的递归处理，r数组和sa数组的大小都要是3*n
void dc3(int *r,int *sa,int n,int m) { //rn数组保存的是递归处理的新字符串，san数组是新字符串的sa
    int i , j , *rn = r+n , *san = sa+n , ta = 0 ,tb = (n+1)/3 , tbc = 0 , p;
    r[n] = r[n+1] = 0;
    for(i=0; i<n; i++) {
        if(i%3!=0)
            wa[tbc++]=i; //tbc表示起始位置模3为1或2的后缀个数
    }
    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;
    }
//对所有起始位置模3等于0的后缀排序
    for(i=0; i<tbc; i++) {
        if(san[i]<tb)
            wb[ta++]=san[i]*3;
    }
    if(n%3==1)  //n%3==1，要特殊处理suffix(n-1)
        wb[ta++]=n-1;
    sort(r,wb,wa,ta,m);
    for(i=0; i<tbc; i++)
        wv[wb[i]=G(san[i])]=i;
//合并所有后缀的排序结果，保存在sa数组中
    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;
}

//height[i]=suffix(sa[i-1])和suffix(sa[i])的最长公共前缀，也就是排名相邻的两个后缀的最长公共前缀
void calheight(int *r,int *sa,int n) {
    int i,j,k=0;
    for(i=1; i<=n; i++)
        rank1[sa[i]]=i;
    for(i=0; i<n; height[rank1[i++]]=k)
        for(k?k--:0,j=sa[rank1[i]-1]; r[i+k]==r[j+k]; k++);
}

int a[N] ;
int mx ;
bool check(int n, int m ,int mid){
    int cnt = 1 ;
    for (int i = 1 ; i <= n ; i ++ ){
        if(height[i] >= mid){
            cnt ++ ;
            if(cnt >= m)return 1 ;
        }else cnt = 1 ;
    }
    return 0 ;
}
int main() {
    int n , m ;
    mx = 0 ;
    int ans = 0 ;
    scanf("%d%d",&n , &m) ;
    for (int i = 0 ; i < n ; i ++ ){
        scanf("%d",&a[i]) ;
        mx = max(mx ,a[i]) ;
    }
    for (int i = 0 ; i < n ; i ++ )r[i] = a[i] ;
    r[n] = 0 ;
    //cout << mx << endl;
    dc3(r , sa , n + 1 , mx + 1 ) ;
    calheight(r, sa ,n) ;
   // cout << mx << endl;
    int l = 1 , r = n ;
    while(r >= l){
        int mid = r + l >> 1 ;
        if(check(n , m , mid )){//找到连续至少m个大于mid公共前缀，更新答案。
            ans = max(ans , mid) ;
            l = mid + 1 ;
        }else r = mid - 1 ;
    }
    cout << ans << endl;
    return 0 ;
}



例 5 ：不相同的子串的个数（ spoj694,spoj705 ）
给定一个字符串，求不相同的子串的个数。
[解法]：
对于每一次新加进来的后缀 suffix(sa[k]), 它将产生 n-sa[k]+1 个新的前缀。但是其中有
height[k] 个是和前面的字符串的前缀是相同的。所以 suffix(sa[k]) 将 “ 贡献 ”
出 n-sa[k]+1- height[k] 个不同的子串。累加后便是原问题的答案。这个做法

的时间复杂度为 O(n) 。

SPOJ 694 和SPOJ 705是一样的，就是705的N= 5W，用后缀数组可以轻松搞掉。

处理完height数组之后，直接利用上述公式，求出所有子串。

多校第三场的1002我就是用的这个模版，但是T了。。。。

好吧，不吐槽了。

//spoj 694
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstring>
#include <queue>
#include <set>
#include <vector>
#include <stack>
#include <map>
#include <iomanip>
#define PI acos(-1.0)
#define Max 2505
#define inf 1<<28
#define LL(x) ( x << 1 )
#define RR(x) ( x << 1 | 1 )
#define REP(i,s,t) for( int i = ( s ) ; i <= ( t ) ; ++ i )
#define ll long long
#define mem(a,b) memset(a,b,sizeof(a))
#define mp(a,b) make_pair(a,b)
#define PII pair<int,int>
using namespace std;

/****后缀数组模版****/
#define N 1005
#define F(x)((x)/3+((x)%3==1?0:tb)) //F(x)求出原字符串的suffix(x)在新的字符串中的起始位置
#define G(x)((x)<tb?(x)*3+1:((x)-tb)*3+2) //G(x)是计算新字符串的suffix(x)在原字符串中的位置，和F(x)为互逆运算
int wa[N],wb[N],wv[N],WS[N];
int sa[N*3] ;
int rank1[N],height[N];
int r[N*3];

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;
}

//注意点：为了方便下面的递归处理，r数组和sa数组的大小都要是3*n
void dc3(int *r,int *sa,int n,int m) { //rn数组保存的是递归处理的新字符串，san数组是新字符串的sa
    int i , j , *rn = r+n , *san = sa+n , ta = 0 ,tb = (n+1)/3 , tbc = 0 , p;
    r[n] = r[n+1] = 0;
    for(i=0; i<n; i++) {
        if(i%3!=0)
            wa[tbc++]=i; //tbc表示起始位置模3为1或2的后缀个数
    }
    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;
    }
//对所有起始位置模3等于0的后缀排序
    for(i=0; i<tbc; i++) {
        if(san[i]<tb)
            wb[ta++]=san[i]*3;
    }
    if(n%3==1)  //n%3==1，要特殊处理suffix(n-1)
        wb[ta++]=n-1;
    sort(r,wb,wa,ta,m);
    for(i=0; i<tbc; i++)
        wv[wb[i]=G(san[i])]=i;
//合并所有后缀的排序结果，保存在sa数组中
    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;
}

//height[i]=suffix(sa[i-1])和suffix(sa[i])的最长公共前缀，也就是排名相邻的两个后缀的最长公共前缀
void calheight(int *r,int *sa,int n) {
    int i,j,k=0;
    for(i=1; i<=n; i++)
        rank1[sa[i]]=i;
    for(i=0; i<n; height[rank1[i++]]=k)
        for(k?k--:0,j=sa[rank1[i]-1]; r[i+k]==r[j+k]; k++);
}

inline void RD(int &ret) {
    char c;
    do {
        c = getchar();
    } while(c < '0' || c > '9') ;
    ret = c - '0';
    while((c=getchar()) >= '0' && c <= '9')
        ret = ret * 10 + ( c - '0' );
}
inline void OT(int a){
    if(a >= 10)OT(a / 10) ;
    putchar(a % 10 + '0') ;
}
char a[N] ;
int main() {
    int T ;
    cin >> T ;
    while( T -- ){
        cin >> a ;
        int l = strlen(a) ;
        for (int i = 0 ; i < l ; i ++ )r[i] = a[i] ;
        r[l] = 0 ;
        dc3(r , sa , l + 1 , 200) ;
        calheight(r , sa , l ) ;
        int ans = 0 ;
        for (int i = 1 ; i <= l ; i ++ ){
            ans += l - sa[i] - height[i] ;
        }
        cout << ans << endl;
    }
    return 0 ;
}





例 6 ：最长回文子串（ ural1297 ）
给定一个字符串，求最长回文子串。
[解法]：
将整个字 符串反过来写在原字符串后面，中间用一个特殊的字符隔开。这样就把问题变为 了
求这个新的字符串的某两个后缀的最长公共前缀。
eg：aabebf ----> aabebf&fbebaa


例 7 ：连续重复子串 (pku2406)
给定一个字符串 L ，已知这个字符串是由某个字符串 S 重复 R 次而得到的，
求 R 的最大值。
[解法]：
做法比较简单，穷举字符串 S 的长度 k ，然后判断是否满足。判断的时候，
先看字符串 L 的长度能否被 k 整除，再看 suffix(1) 和 suffix(k+1) 的最长公共
前缀是否等于 n-k 。
hit：此题更好的是考察KMP的next
int k=len-next[len];
if(len%k==0) fprintf(fout,"%d\n",len/k);
else fprintf(fout,"1\n");


例 8 ：重复次数最多的连续重复子串 (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 次。最 后
看最大值是多少。


例 9 ：最长公共子串 (pku2774,ural1517) 
给定两个字符串 A 和 B ，求最长公共子串。
连接字符串，O(N)扫描 
//POJ 2774 HDU 1403
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstring>
#include <queue>
#include <set>
#include <vector>
#include <stack>
#include <map>
#include <iomanip>
#define PI acos(-1.0)
#define Max 2505
#define inf 1<<28
#define LL(x) ( x << 1 )
#define RR(x) ( x << 1 | 1 )
#define REP(i,s,t) for( int i = ( s ) ; i <= ( t ) ; ++ i )

#define mem(a,b) memset(a,b,sizeof(a))
#define mp(a,b) make_pair(a,b)
#define PII pair<int,int>
using namespace std;

#define N 200005
/****后缀数组模版****/
#define F(x)((x)/3+((x)%3==1?0:tb)) //F(x)求出原字符串的suffix(x)在新的字符串中的起始位置
#define G(x)((x)<tb?(x)*3+1:((x)-tb)*3+2) //G(x)是计算新字符串的suffix(x)在原字符串中的位置，和F(x)为互逆运算
int wa[N],wb[N],wv[N],WS[N];
int sa[N*3] ;
int rank1[N],height[N];
int r[N*3];

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;
}

//注意点：为了方便下面的递归处理，r数组和sa数组的大小都要是3*n
void dc3(int *r,int *sa,int n,int m) { //rn数组保存的是递归处理的新字符串，san数组是新字符串的sa
    int i , j , *rn = r+n , *san = sa+n , ta = 0 ,tb = (n+1)/3 , tbc = 0 , p;
    r[n] = r[n+1] = 0;
    for(i=0; i<n; i++) {
        if(i%3!=0)
            wa[tbc++]=i; //tbc表示起始位置模3为1或2的后缀个数
    }
    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;
    }
//对所有起始位置模3等于0的后缀排序
    for(i=0; i<tbc; i++) {
        if(san[i]<tb)
            wb[ta++]=san[i]*3;
    }
    if(n%3==1)  //n%3==1，要特殊处理suffix(n-1)
        wb[ta++]=n-1;
    sort(r,wb,wa,ta,m);
    for(i=0; i<tbc; i++)
        wv[wb[i]=G(san[i])]=i;
//合并所有后缀的排序结果，保存在sa数组中
    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;
}

//height[i]=suffix(sa[i-1])和suffix(sa[i])的最长公共前缀，也就是排名相邻的两个后缀的最长公共前缀
void calheight(int *r,int *sa,int n) {
    int i,j,k=0;
    for(i=1; i<=n; i++)
        rank1[sa[i]]=i;
    for(i=0; i<n; height[rank1[i++]]=k)
        for(k?k--:0,j=sa[rank1[i]-1]; r[i+k]==r[j+k]; k++);
}

char a[N] ;
int ans = 0 ;
int main() {
    while(scanf("%s",a) != EOF) {
        ans = 0 ;
        int l = strlen(a) ;
        a[l] = '*' ;
        scanf("%s", a + l + 1) ;
        int ll = strlen(a) ;
        for (int i = 0 ; i < ll ; i ++ )r[i] = (int)a[i] ;
        r[ll] = 0 ;
        dc3(r ,sa ,ll + 1,128) ;
        calheight(r , sa , ll) ;
        for (int i = 1 ; i <= ll ; i ++ ) {
            if((sa[i] > l && sa[i - 1] < l ) || (sa[i] < l && sa[i - 1] > l) ) {
                ans = max(ans ,height[i]) ;
            }
        }
        cout << ans << endl;
    }
    return 0 ;
}

其实两道题差不多，只是这道题不只是找到两个字串的最长公共前缀，而且要输出这个公共的字串。

那么我们可以在二分答案的时候记录他的首地址。而sa[]数组就可以帮助我们轻松的完成这个任务。

我们只需要每次更新答案的时候，更新sa[]数组即可。

最后输出一个长度为ans的最长公共字串即可。

//ural 1517
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstring>
#include <queue>
#include <set>
#include <vector>
#include <stack>
#include <map>
#include <iomanip>
#define PI acos(-1.0)
#define Max 2505
#define inf 1<<28
#define LL(x) ( x << 1 )
#define RR(x) ( x << 1 | 1 )
#define REP(i,s,t) for( int i = ( s ) ; i <= ( t ) ; ++ i )

#define mem(a,b) memset(a,b,sizeof(a))
#define mp(a,b) make_pair(a,b)
#define PII pair<int,int>
using namespace std;

#define N 200005
/****后缀数组模版****/
#define F(x)((x)/3+((x)%3==1?0:tb)) //F(x)求出原字符串的suffix(x)在新的字符串中的起始位置
#define G(x)((x)<tb?(x)*3+1:((x)-tb)*3+2) //G(x)是计算新字符串的suffix(x)在原字符串中的位置，和F(x)为互逆运算
int wa[N],wb[N],wv[N],WS[N];
int sa[N*3] ;
int rank1[N],height[N];
int r[N*3];

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;
}

//注意点：为了方便下面的递归处理，r数组和sa数组的大小都要是3*n
void dc3(int *r,int *sa,int n,int m) { //rn数组保存的是递归处理的新字符串，san数组是新字符串的sa
    int i , j , *rn = r+n , *san = sa+n , ta = 0 ,tb = (n+1)/3 , tbc = 0 , p;
    r[n] = r[n+1] = 0;
    for(i=0; i<n; i++) {
        if(i%3!=0)
            wa[tbc++]=i; //tbc表示起始位置模3为1或2的后缀个数
    }
    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;
    }
//对所有起始位置模3等于0的后缀排序
    for(i=0; i<tbc; i++) {
        if(san[i]<tb)
            wb[ta++]=san[i]*3;
    }
    if(n%3==1)  //n%3==1，要特殊处理suffix(n-1)
        wb[ta++]=n-1;
    sort(r,wb,wa,ta,m);
    for(i=0; i<tbc; i++)
        wv[wb[i]=G(san[i])]=i;
//合并所有后缀的排序结果，保存在sa数组中
    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;
}

//height[i]=suffix(sa[i-1])和suffix(sa[i])的最长公共前缀，也就是排名相邻的两个后缀的最长公共前缀
void calheight(int *r,int *sa,int n) {
    int i,j,k=0;
    for(i=1; i<=n; i++)
        rank1[sa[i]]=i;
    for(i=0; i<n; height[rank1[i++]]=k)
        for(k?k--:0,j=sa[rank1[i]-1]; r[i+k]==r[j+k]; k++);
}

char a[N] ;
int ans = 0 ;
int main() {
    int x ;
    cin >> x ;
    scanf("%s",a) ;
    ans = 0 ;
    int l = strlen(a) ;
    a[l] = '*' ;
    scanf("%s", a + l + 1) ;
    int ll = strlen(a) ;
    for (int i = 0 ; i < ll ; i ++ )r[i] = (int)a[i] ;
    r[ll] = 0 ;
    dc3(r ,sa ,ll + 1,128) ;
    calheight(r , sa , ll) ;
    int now = -1 ;
    for (int i = 1 ; i <= ll ; i ++ ) {
        if((sa[i] > l && sa[i - 1] < l ) || (sa[i] < l && sa[i - 1] > l) ) {//保证这个sa[i]和sa[i - 1]是位于不同的字符串中的
            if(ans < height[i]) {
                ans = height[i] ;
                now = sa[i - 1] ;
            }
        }
    }
    //cout << now << " " << ans << endl;
    for (int i = now ; i < now + ans ; i ++ )cout << a[i] ;
    cout << endl;
    //cout << ans << endl;

    return 0 ;
}



例 10: 长度不小于 k 的公共子串的个数 (pku3415)
给定两个字符串 A 和 B ，求长度不小于 k 的公共子串的个数（可以相同）。
http://hi.baidu.com/zfy0701/blog/item/f2278a0928991dca3bc763a0.html


例 11: 不小于 k 个字符串中的最长子串 (pku3294)
给定 n 个字符串，求出现在不小于 k 个字符串中的最长子串。
[解法]：
参见例3：扩展到看k个一样


例 12: 每个字符串至少出现两次且不重叠的最长子串 (spoj220)
给定 n 个字符串，求在每个字符串中至少出现两次且不重叠的最长子串。
[解法]：
做法和上题大同小异，也是先将 n 个字符串连起来，中间用不相同的且没 有
出现在字符串中的字符隔开，求后缀数组。然后二分答案，再将后缀分组。判 断
的时候，要看是否有一组后缀在每个原来的字符串中至少出现两次，并且在每 个
原来的字符串中，后缀的起始位置的最大值与最小值之差是否不小于当前答案
（判断能否做到不重叠，如果题目中没有不重叠的要求，那么不用做此判断）。
这个做法的时间复杂度为 O(nlogn) 。


例 13: 出现或反转后出现在每个字符串中的最长子串 (PKU1226)
给定 n 个字符串，求出现或反转后出现在每个字符串中的最长子串。
[解法]：
连接字符串（正反向），二分答案，判断是否都出现过。


后缀数组题目推荐
1412
后缀数组的题目


Uva11475


题目大意 给定一个字符串在字符串的末尾加最少的字符是的该字符串成为回文串。
[这个题目我已经加到OJ上了 题号是1139 这个题目根本不用后缀数组的 而且后缀数组的效率也是不最高的 ——Sempr补充]


Pku2774 : 求两个字符串的最长公共子串长度。


Whu1069 求两个字符串的最长公共子串长度。


pku3581 ：http://acm.pku.edu.cn/JudgeOnline/problem?id=3581
题目大意：给定一个数组{A1, A2, …, An} 满足A1 > A2, …, An,把该数组分成三段，单独翻转，使得数组的字典序最小。





http://acm.pku.edu.cn/JudgeOnline/problem?id=3623 // AC


题目大意：给定一个字符数组，可以从数组的开头或者结尾取出元素，按取出顺序排成一列，使得他的字典序最小。


http://acm.pku.edu.cn/JudgeOnline/problem?id=1743
题目大意：求最长不重叠差为定值子串的长度


-》最长不重叠重复子串的长度


(1)二分答案


（2）线性扫描


http://acm.pku.edu.cn/JudgeOnline/problem?id=3450


题目大意：求多个字符串的最长公共字串。


http://acm.pku.edu.cn/JudgeOnline/problem?id=3080


题目大意：求多个字符串的最长公共子串（弱）。


用后缀数组比较麻烦，可以枚举答案，用kmp判定。


Waterloo：life forms：http://acm.pku.edu.cn/JudgeOnline/problem?id=3294


题目大意：超过一半的串的公共最长子串。


http://acm.pku.edu.cn/JudgeOnline/problem?id=3415


题目大意：求两个字符串的长度大于k公共字串的个数。


Whu1084 http://acm.whu.edu.cn/oak/problem/problem.jsp?problem_id=1084


题目大意：求最长不重叠重复字串的长度和个数。


Toj2171 http://acm.tju.edu.cn/toj/showp2171.html


题目大意：统计每子串可分成可分成多少个重复串




http://acm.pku.edu.cn/JudgeOnline/problem?id=2758
题目大意：给定一个串，要求支持两种操作：插入单个字符或者询问从两个位置开始的最大匹配长度
后缀数组算法概述及习题
Gene_I must wait for the sunrise
10-24 416
后缀数组概述 一、适用问题 后缀数组的题目非常灵活多变，主要涉及字符串所有后缀的字典序比较以及最长公共前缀。 本文主要介绍后缀数组的一些经典应用，虽然是经典应用，但是其思想应该属于后缀数组类问题的本质思想。 二、算法介绍 求解后缀数组的算法主要有倍增法、DC3DC3DC3 算法，具体的算法实现此处就略过了，想要具体了解的话可以自行 googlegooglegoogle 搜索。 下文给出的后缀数组模...
算法习题之DC3生成后缀数组
最新发布
sam475259540的博客
07-24 137
DC3
后缀数组例题，对学习后缀数组有一点帮组
07-11
学习后缀数组有一点帮组，学习了一周的后缀数组，献给正在为ACM奋斗的同学们
后缀数组 亚马逊笔试题最后一道题考了这道题
松篁
10-22 252
今天下午看完了后缀树的原理2011.10.26 ，这篇文章写得很赞：http://hi.baidu.com/bupt1/blog/item/7391c0246fdb7a1f918f9dca.html 本文转自http://hi.baidu.com/lewutian/blog/item/4d098138d29c34f9b311c725.html 单...
算法合集之《后缀数组——处理字符串的有力工具》
diaocuiguo2493的博客
04-06 249
后缀数组： sa[i]:表示排名第i个的首字母位置 Rank[i]:第i个数的排名 Height[i]:sa[i]和sa[i-1]的最长公共前缀 suffix(j) 和suffix(k) 的最长公共前缀为height[rank[j]+1], height[rank[j]+2], height[rank[j]+3], … ,height[rank[k]]中的最小值。 ...
后缀数组题集
帅比王的博客
10-17 573
sa[i]：排名为i的后缀起始位置是多少。 rank[i]：从 i 位置起始的后缀在所有后缀中字典序排序后序号，与sa互逆。 lcp[i]：S[sa[i] ,…] 与 S[sa[i+1] , …]的最长公共前缀。 Musical Theme 测试地址 题意简述 给n个数组成的串，求是否有多个“相似”且不重叠的子串的长度大于等于5，两个子串相似当且仅当长度相等且每一位的数字差都相等。 解题思路 本题...
后缀数组题目小结
ACM！荣耀之路！
06-10 4994
因为有两次遇到了后缀数组的题目，于是这才下定决心学习了一下后缀数组，虽然对后缀数组并没有说理解得很透彻，但是一些基本得模板还是会用了，起码对付一些一般的后缀数组应该还是没有问题的了 对于后缀数组的原理什么的我就不多说了，毕竟我理解的不算很透，只是说对于模板得出关键的三个数组还算有点使用的心得而已，具体的大家完全可以去看论文，百度可以找到很多，里面也说的很详细，大部分模板都是从那里面来的
洛谷 P2870 [USACO07DEC]Best Cow Line G（后缀数组）
qq_38232157的博客
11-23 1033
后缀数组
POJ 2406 后缀数组 或 KMP
即使摸爬滚打，满身泥泞，我也要前进
09-12 385
简略题意：求解一个连续重复串的最大重复次数。连续重复串：如果一个字符串L由字符串S重复R次得到，那么L是一个连续重复串，R是这个字符串的重复次数。KMP的解法和后缀数组异曲同工。 不过为了练习后缀数组，这里只说后缀数组的解法。吐槽一下： 虽然是KMP的水题，不过用后缀数组写起来还是很烦的。 1. 卡时间，倍增的后缀数组过不去。 2. 卡空间，因为串很长，所以不能用一般O(nlogn)O(nl
后缀数组练习题若干
水
10-13 3678
POJ 1743    不可重叠最长重复子串 二分答案。 即子串的长度，假设为k时。 利用height数组，将排序后的后缀分为若干组。 每组内的height值都不小于k。 然后只需查看组内是否有满足要求的两个不会产生重叠的子串即可。 #include #include #include #include #include #include #include #defin
后缀数组--经典题型
weixin_30699955的博客
02-21 121
后缀例题 转自--后缀数组---处理字符串的有力工具 例1 ：最长公共前缀 问题描述：给定一个字符串，询问某两个后缀的最长公共前缀。 算法分析：问题可以转化为：height数组的区间最小值。所以加上一个 RMQ+倍增算法模板。可以O(1)查询。 题目+代码：略。 例2：可重叠最长重复子串 问题描述：给定一个字符串，求最长重复子串，这两个子串可以重...
后缀数组练习题
lb2003
08-21 268
POJ1743 思路 由于可能转调， 现设匹配长度lenlenlen，A[i∼i+len−1]=A[j∼j+len−1]−w(j&gt;i+len−1)A[i\sim i+len-1]=A[j\sim j+len-1]-w(j&gt;i+len-1)A[i∼i+len−1]=A[j∼j+len−1]−w(j>i+len−1)，w就是转调值，但这样并不好处理。 由于是区间加上(...
后缀数组题目集
我们仍未知道那天所看见的花的名字。
10-02 155
Musical Theme #include <iostream> #include <stdio.h> #include <string.h> #include <stack> #include <queue> #include <map> #include <set> #include <vector> #include <math.h> #include <bitset> #incl
练习——后缀数组题目
ALXPCUN的博客
04-27 1168
BZOJ 1717 题意：给一个字符串，求最长的出现至少K次的子串，子串可以重叠。 难度：* 和模型一样，直接上。 CODE： #include #include #include using namespace std; const int MAX_N = 20005; int n, K, a[MAX_N]; void init() { scanf("%d%d", &n
后缀数组题表
linjiayang2016的博客
08-17 277
定义 1.sa[i]1.sa[i]1.\quad sa[i] 表示排名为 iii 的后缀的起始位置。 2.rank[i]2.rank[i]2.\quad rank[i] 表示起始位置为 iii 的后缀的排名。 3.lcp(i,j)3.lcp(i,j)3.\quad lcp(i,j) 表示起始位置为 iii 的后缀和起始位置为 jjj 的后缀的最长公共前缀。 4.height[i]=lcp(...
后缀数组练习题bzoj 1031 后缀数组模板题目
蒟蒻的博客
07-27 871
题目戳这里http://www.lydsy.com/JudgeOnline/problem.php?id=1031 这是一道显然的后缀数组模板题目。 这道题我们发现只要求出这几个循环的字符串排列就好了，那么我们显然想到把它扩展2倍，然后求一边rank和SA数组，这样我们得到了需要的前一半rank数组，把它离散一下就是这个循环圈的排列顺序了。 AC代码：#include<cstdio> #inc
后缀数组习题集
天亮说晚安
07-21 3411
转自http://hi.baidu.com/zfy0701/blog/item/f2278a0928991dca3bc763a0.html 字符串算法通常是非常优雅的，尤其是后缀数组啊，前、后缀自动机啊，Trie，KMP，BM，BOM，Shift - Or，RK ...... 我准备写写POJ上一些字符串问题的文章，第一篇是我认为在竞赛中字符串问题用处最大的一个工具：后缀数组。 先帖点后缀数
Tyvj_P1860 后缀数组(后缀数组模板题)
BeiYu
03-30 906
Tyvj传送门时间: 1000ms / 空间: 131072KiB / Java类名: Main 描述 我们定义一个字符串的后缀suffix(i)表示从s[i]到s[length(s)]这段子串。 后缀数组（Suffix array）SA[i]中存放着一个排列，满足suffix(sa[i])< suffix(sa[i+1]) 按照字典序方式比较 定义height[i]表示suffix(sa[
HDOJ 题目5442 Favorite Donut（后缀数组）
Jogging_Clown
10-02 420
Favorite Donut Time Limit: 1500/1000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others) Total Submission(s): 2138    Accepted Submission(s): 518 Problem Description Lulu has a
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值