后缀数组总结

后缀：字符 串 r 的 从 第 i 个 字 符 开 始 的 后 缀 表 示 为 Suffix(i)
后缀数组：后缀数组 SA 是一个一维数组，SA(i)表示排序后第i个后缀数组的起始位置为SA(i)
名次数组：名次数组 Rank[i]保存的是 Suffix(i)在所有后缀中从小到大排列的“名次”。

２倍增算法

待排序的字符串放在 r 数组中，从 r[0]到 r[n-1]，长度为 n，且最大值小于 m。为了函数操作的方便，约定除 r[n-1]外所有的 r[i]都大于 0, r[n-1]=0。函数结束后，结果放在 sa 数组中，从 sa[0]到 sa[n-1]。

函数的第一步，要对长度为 1 的字符串进行排序。一般来说，在字符串的题目中，r 的最大值不会很大，所以这里使用了基数排序。如果 r 的最大值很大，那么把这段代码改成快速排序。代码：

for(i=0;i<m;i++) ws[i]=0;
for(i=0;i<n;i++) ws[x[i]=r[i]]++;
for(i=1;i<m;i++) ws[i]+=ws[i-1];
for(i=n-1;i>=0;i--) sa[--ws[x[i]]]=i;

这里 x 数组保存的值相当于是 rank 值。下面的操作只是用 x 数组来比较字符的大小，所以没有必要求出当前真实的 rank 值。接下来进行若干次基数排序，在实现的时候，这里有一个小优化。基数排序要分两次，第一次是对第二关键字排序，第二次是对第一关键字排序。对第二关键字排序的结果实际上可以利用上一次求得的 sa 直接算出，没有必要再算一次。代码：

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;

其中变量j是当前字符串的长度，数组y保存的是对第二关键字排序的结果 。然后要对第一关键字进行排序，代码：

for(i=0;i<n;i++) wv[i]=x[y[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--) sa[--ws[wv[i]]]=y[i];

这样便求出了新的 sa 值。在求出 sa 后，下一步是计算 rank 值。这里要注意的是，可能有多个字符串的 rank 值是相同的，所以必须比较两个字符串是否完全相同，y 数组的值已经没有必要保存，为了节省空间，这里用 y 数组保存 rank值。这里又有一个小优化，将 x 和 y 定义为指针类型，复制整个数组的操作可以用交换指针的值代替，不必将数组中值一个一个的复制。代码：

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

其中 cmp 函数的代码是：

int cmp(int *r,int a,int b,int l)
{return r[a]==r[b]&&r[a+l]==r[b+l];}

这里可以看到规定 r[n-1]=0 的好处，如果 r[a]=r[b]，说明以 r[a]或 r[b]开头的长度为l的字符串肯定不包括字符r[n-1]，所以调用变量 r[a+l]和 r[b+l]不会导致数组下标越界，这样就不需要做特殊判断。执行完上面的代码后，rank值保存在 x 数组中，而变量 p 的结果实际上就是不同的字符串的个数。这里可以加一个小优化，如果 p 等于 n，那么函数可以结束。因为在当前长度的字符串中 ，已经没有相同的字符串，接下来的排序不会改变 rank 值。例如图 1 中的第四次排序，实际上是没有必要的。对上面的两段代码，循环的初始赋值和终止条件可以这样写：

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

在第一次排序以后，rank 数组中的最大值小于 p，所以让 m=p。整个倍增算法基本写好，代码大约 25行。
算法分析：
倍增算法的时间复杂度比较容易分析。每次基数排序的时间复杂度为 O(n)，排序的次数决定于最长公共子串的长度，最坏情况下，排序次数为 logn 次，所
总的时间复杂度为 O(nlogn)。

DC3 算法

DC3 算法分 3 步：
（1）将所有的后缀分成两部分，一部分是模3不等于0的，比如Suffix[1],Suffix[2],Suffix[4],Suffix[7]等，第二部分是模3等于0的后缀，Suffix[0],Suffix[3]等。首先计算第一部分每个后缀的排名（计算的时候假设没有第二部分的这些后缀）。方法是将Suffix[1]和Suffix[2]连起来（ 连起来之前要把Suffix[1]和Suffix[2]的长度都变为3的倍数，如果不是，就在后面补上字符集中没有且小于字符集中所有字符的字符，比如0）。对于串S=aabaaaaba，Suffix[1]=abaaaaba,Suffix[2]=baaaaba，分别补成3的倍数，Suffix[1]=abaaaaba0,Suffix[2]=baaaaba00，最后拼成的串为abaaaaba0baaaaba00 。如下所示

然后从前向后，每三个字符一组，即aba,aaa,ba0,baa,aab,a00，我们发现，他们分别是Suffix[1],Suffix[4],Suffix[7],Suffix[2],Suffix[5],Suffix[8] 的前3个字母。我们求出这六个的排名为4,2,5,6,3,1（注意，如果排序后还有相同的数字，也就是还有两个相同的串，比如3,2,4,5,2,1，那么要继续求，因为两个2之后的数字4大于1，所以第二的位置的2代表的后缀大于第5个位置的2代表的后缀。其实这个问题跟刚才的问题是相同的，所以可以递归求）。这样，我们最后得到了所有模3不等于0的位置的后缀的排名。
2）计算模3等于0的位置的排名。这些位置的后缀，可以看做一个字符加上某个第一部分的一个后缀，这也很容易通过一次基数排序（就像倍增法的二元组一样）求得。对于上面的串，模3为0的后缀的排名为

Suffix[9]<Suffix[3]<Suffix[0]<Suffix[6]

（3）合并第一部分和第二部分的排名。注意，上面求出的第一部分第二部分的排名都没有考虑另外一部分。合并的时候我们需要比较第一部分的某个后缀和第二部分的某个后缀。分两种情况。第一种是比较Suffix[3*i] 和Suffix[3*j+1]，我们把它们看做：

Suffix[3*i]   = S[3*i]   + Suffix[3*i+1]
Suffix[3*j+1] = S[3*j+1] + Suffix[3*j+2]

Suffix[3*i+1]和Suffix[3*j+2]可以直接比较，因为它们都属于第一部分，而S[3*i]和S[3*j+1]也可以直接比较；
第二种情况是Suffix[3*i] 和Suffix[3*j+2]，把它们看做是

Suffix[3*i]=   S[3*i]   + S[3*i+1] + Suffix[3*i+2]
Suffix[3*j+2]= S[3*j+2] + S[3*j+3] + Suffix[3*(j+1)+1]

Suffix[3*i+2]和Suffix[3*(j+1)+1]可以直接比较，它们都属于第二部分。而 前面是两个单个字符，可以直接比较。这样，就可以合并所有的后缀得到答案。

height数组

height 数组：定义 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]]中的最小值。

h 数组有以下性质：

h[rank(suffix(i))]≥h[rank(suffix(i-1))]-1

证明：
设 suffix(k)是排在 suffix(i-1)前一名的后缀，则它们的最长公共前缀是h[i-1]。那么 suffix(k+1)将排在 suffix(i)的前面（这里要求 h[i-1]>1，如果h[i-1]≤1，原式显然成立）并且 suffix(k+1)和 suffix(i)的最长公共前缀是h[i-1]-1，所以 suffix(i)和在它前一名的后缀的最长公共前缀至少是 h[i-1]-1。按照 h[1],h[2],……,h[n]的顺序计算,并利用 h 数组的性质，时间复杂度可以降为 O(n)。
具体实现：
实现的时候其实没有必要保存 h 数组，只须按照 h[rank(1)],h[rank(2)],……,h[rank(n)]的顺序计算即可。代码：

int rank[maxn],height[maxn];
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;
}

板子：

倍增法

/*
*suffix array
*倍增算法 O(n*logn)
*待排序数组长度为n,放在0~n-1中，在最后面补一个0
*da(str ,n+1,sa,rank,height, , );//注意是n+1;
*例如：
*n = 8;
*num[] = { 1, 1, 2, 1, 1, 1, 1, 2, $ };注意num最后一位为0，其他大于0
*rank[] = { 4, 6, 8, 1, 2, 3, 5, 7, 0 };rank[0~n-1]为有效值，rank[n]必定为0无效值
*sa[]= { 8, 3, 4, 5, 0, 6, 1, 7, 2 };sa[1~n]为有效值，sa[0]必定为n是无效值
*height[]= { 0, 0, 3, 2, 3, 1, 2, 0, 1 };height[2~n]为有效值
*
*/
const int MAXN=20010;
int t1[MAXN],t2[MAXN],c[MAXN];//求SA数组需要的中间变量，不需要赋值
//待排序的字符串放在s数组中，从s[0]到s[n-1],长度为n,且最大值小于m,
//除s[n-1]外的所有s[i]都大于0，r[n-1]=0
//函数结束以后结果放在sa数组中
bool cmp(int *r,int a,int b,int l)
{
    return r[a] == r[b] && r[a+l] == r[b+l];
}
void da(int str[],int sa[],int rank[],int height[],int n,int m)
{
    n++;
    int i, j, p, *x = t1, *y = t2;
    //第一轮基数排序，如果s的最大值很大，可改为快速排序
    for(i = 0;i < m;i++)c[i] = 0;
    for(i = 0;i < n;i++)c[x[i] = str[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(j = 1;j <= n; j <<= 1)
    {
        p = 0;
        //直接利用sa数组排序第二关键字
        for(i = n-j; i < n; i++)y[p++] = i;//后面的j个数第二关键字为空的最小
        for(i = 0; i < n; i++)if(sa[i] >= j)y[p++] = sa[i] - j;
        //这样数组y保存的就是按照第二关键字排序的结果
        //基数排序第一关键字
        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];
        //根据sa和x数组计算新的x数组
        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],j)?p-1:p++;
        if(p >= n)break;
        m = p;//下次基数排序的最大值
    }
    int k = 0;
    n--;
    for(i = 0;i <= n;i++)rank[sa[i]] = i;
    for(i = 0;i < n;i++)
    {
        if(k)k--;
        j = sa[rank[i]-1];
        while(str[i+k] == str[j+k])k++;
        height[rank[i]] = k;
    }
}
int rank[MAXN],height[MAXN];
int RMQ[MAXN];
int mm[MAXN];
int best[20][MAXN];
void initRMQ(int n)
{
    mm[0]=-1;
    for(int i=1;i<=n;i++)
        mm[i]=((i&(i-1))==0)?mm[i-1]+1:mm[i-1];
    for(int i=1;i<=n;i++)best[0][i]=i;
    for(int i=1;i<=mm[n];i++)
    for(int j=1;j+(1<<i)-1<=n;j++)
    {
        int a=best[i-1][j];
        int b=best[i-1][j+(1<<(i-1))];
        if(RMQ[a]<RMQ[b])best[i][j]=a;
        else best[i][j]=b;
    }
}
int askRMQ(int a,int b)
{
    int t;
    t=mm[b-a+1];
    b-=(1<<t)-1;
    a=best[t][a];b=best[t][b];
    return RMQ[a]<RMQ[b]?a:b;
}
int lcp(int a,int b)
{
    a=rank[a];b=rank[b];
    if(a>b)swap(a,b);
    return height[askRMQ(a+1,b)];
}
char str[MAXN];
int r[MAXN];
int sa[MAXN];
int main()
{
    while(scanf("%s",str) == 1)
    {
        int len = strlen(str);
        int n = 2*len + 1;
        for(int i = 0;i < len;i++)r[i] = str[i];
        for(int i = 0;i < len;i++)r[len + 1 + i] = str[len - 1 - i];
        r[len] = 1;
        r[n] = 0;
        da(r,sa,rank,height,n,128);
        for(int i=1;i<=n;i++)RMQ[i]=height[i];
        initRMQ(n);
        int ans=0,st;
        int tmp;
        for(int i=0;i<len;i++)
        {
            tmp=lcp(i,n-i);//偶对称
            if(2*tmp>ans)
            {
                ans=2*tmp;
                st=i-tmp;
            }
            tmp=lcp(i,n-i-1);//奇数对称
            if(2*tmp-1>ans)
            {
                ans=2*tmp-1;
                st=i-tmp+1;
            }
        }
        str[st+ans]=0;
        printf("%s\n",str+st);
    }
    return 0;
}

DC3

da[]和str[]数组要开大三倍，相关数组也是三倍
/*
* 后缀数组
* DC3算法，复杂度O(n)
* 所有的相关数组都要开三倍
*/
const int MAXN = 2010;
#define F(x) ((x)/3+((x)%3==1?0:tb))
#define G(x) ((x)<tb?(x)*3+1:((x)-tb)*3+2)
int wa[MAXN*3],wb[MAXN*3],wv[MAXN*3],wss[MAXN*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++)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--)
        b[--wss[wv[i]]] = a[i];
}
void dc3(int *r,int *sa,int n,int m)
{
    int i, j, *rn = r + n;
    int *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;
    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++];
}
//str和sa也要三倍
void da(int str[],int sa[],int rank[],int height[],int n,int m)
{
    for(int i = n;i < n*3;i++)
    str[i] = 0;
    dc3(str, sa, n+1, m);
    int i,j,k = 0;
    for(i = 0;i <= n;i++)rank[sa[i]] = i;
    for(i = 0;i < n; i++)
    {
        if(k) k--;
        j = sa[rank[i]-1];
        while(str[i+k] == str[j+k]) k++;
        height[rank[i]] = k;
    }
}