后缀数组练习题（转）
原文：http://hi.baidu.com/lewutian/blog/item/4d098138d29c34f9b311c725.html
后缀数组经典思想：多串合并+二分答案+最优性--->可行性
例 1 ：最长公共前缀
给定一个字符串，询问某两个后缀的最长公共前缀。 // 直接套用，ans=min( height[ i ] )+rmq k<i<=j
例 2 ：可重叠最长重复子串
给定一个字符串，求最长重复子串，这两个子串可以重叠。 // ans=max( hegiht[ i ] ) 0<=i<len
例 3 ：不可重叠最长重复子串（ pku1743 ）
给定一个字符串，求最长重复子串，这两个子串不能重叠。 // 二分转化为判定性问题
例 4 ：可重叠的 k 次最长重复子串（ pku3261 ）
给定一个字符串，求至少出现 k 次的最长重复子串，这 k 个子串可以重叠。 // 同上，也是二分
例 5 ：不相同的子串的个数（ spoj694,spoj705 ）
给定一个字符串，求不相同的子串的个数。
[解法]：
对于每一次新加进来的后缀 suffix(sa[k]), 它将产生 n-sa[k]+1 个新的前缀。但是其中有
height[k] 个是和前面的字符串的前缀是相同的。所以 suffix(sa[k]) 将 “ 贡献 ”
出 n-sa[k]+1- height[k] 个不同的子串。累加后便是原问题的答案。这个做法
例 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)扫描
例 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
题目大意：给定一个串，要求支持两种操作：插入单个字符或者询问从两个位置开始的最大匹配长度
接下来逐步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
题目大意：给定一个串，要求支持两种操作：插入单个字符或者询问从两个位置开始的最大匹配长度