SuffixArray

SuffixSort

后缀数组前置知识

后缀排序\((SuffixSort)\),是后缀数组的核心部分,但我不知道这玩意儿到底是怎么想出来的......(毕竟我不是神仙).然后,这个东西 并不是很难理解,我认为难的地方其实是在\(height_i\)的理解.所以....\(height\)我到现在也没理解.

先说一说后缀排序.

后缀排序是对后缀进行排序,这有啥用呢?如果没有\(height\),后缀数组就失去了它的魅力.但单纯的后缀排序也并非没有用.哎?不对,好像确实没啥用...但是这不影响我们学它.

后缀排序是对一个串的所有后缀进行排序,排序依据就是字典序.

一个显然的想法是把所有后缀都拿出来排一遍序,但显然这亚子太慢了,复杂度高达 \(O(nl \log_2{n})\) 最好也只能是 \(O(nl)\).因为字符串的比较是\(O(L)\)的.那么考虑怎样去优化这个排序.

我们可以发现,每次字符串的比较,如果我们知道这两个字符串相对应的两半的大小关系,那么我们可以直接得到这两个字符串的大小关系(类比线段的两个关键字的排序).这样是可以做到\(O(1)\)判断大小的.

那么我们这里就可以比较自然的想到使用倍增算法.我们先对所有的单个字符进行排序,这是\(O(n \log_2{n})\)的,这个复杂度可以接受,然后我们再对长度为\(2\)的串进行排序,以上一次排完序的单个字符大小关系为关键字.再对长度为\(4\)的串进行排序......以此类推.显然,最后我们一定能得到所有后缀的排序结果.

于是我们就倍增地枚举串的长度,进行排序,复杂度为\(O(n \log_2^2 {n})\).这样的复杂度已经足以应对不太***钻的数据.

但是我们很可能仍然不满足于这样的复杂度.

我们注意到,对于字符串的排序,字符集一般不会太大,这也就告诉我们,基数排序或许是可行的.

事实上,多数情况下,都是可以使用基数排序的.

于是我们考虑基数排序,这其实就是桶排的强化版?或许就是桶排吧...

我们设桶数组是\(cnt\),那么\(pos\)对应的前缀和就是\(pos\)的排名.

要知道的是,基数排序是稳定排序.

于是我们把整个后缀排序的复杂度降至\(O(n \log_2{n})\).

\(sa[i]:\)第 \(i\) 小的后缀的编号.

\(rank[i]:\)编号为 \(i\) 的后缀的排名(从小到大).

于是总的代码长成这个亚子:

#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#define MEM(x,y) memset ( x , y , sizeof ( x ) )
#define rep(i,a,b) for (int i = a ; i <= b ; ++ i)
#define per(i,a,b) for (int i = a ; i >= b ; -- i)

const int N = 2e6 + 100 ;

typedef int one[N] ;

one trk , rk , SA , tmp , h , cnt ;
int n , p ; char s[N] ;

inline void SuffixSort () {
    p = 0 ; rep ( i , 1 , n ) p = std::max ( (int)s[i] , p ) ;
    rep ( i , 1 , n ) ++ cnt[s[i]] ;
    rep ( i , 1 , p ) cnt[i] += cnt[i-1] ;
    per ( i , n , 1 ) SA[cnt[s[i]]--] = i ;
    rk[SA[1]] = p = 1 ;
    rep ( i , 2 , n ) rk[SA[i]] = ( s[SA[i]] == s[SA[i-1]] ? p : ++ p ) ;

    for (int w = 1 ; w <= n ; w <<= 1) {
        MEM ( cnt , 0 ) ;
        rep ( i , 1 , n ) ++ cnt[rk[i+w]] ;
        rep ( i , 1 , p ) cnt[i] += cnt[i-1] ;
        per ( i , n , 1 ) tmp[cnt[rk[i+w]]--] = i ;

        MEM ( cnt , 0 ) ;
        rep ( i , 1 , n ) ++ cnt[rk[i]] ;
        rep ( i , 1 , p ) cnt[i] += cnt[i-1] ;
        per ( i , n , 1 ) SA[cnt[rk[tmp[i]]]--] = tmp[i] ;

        trk[SA[1]] = p = 1 ;
        rep ( i , 2 , n ) trk[SA[i]] = ( rk[SA[i]] == rk[SA[i-1]] && rk[SA[i]+w] == rk[SA[i-1]+w] ) ? p : ++ p ;
        rep ( i , 1 , n ) rk[i] = trk[i] ;
    }
}

这一份代码是参考了 \(RXD\) 大爷的代码.

height数组

后缀数组的核心

\(height[i]:\)第 \(i\) 小的后缀和第 \(i-1\)小的后缀的最长公共前缀，

即 \(LCP(suffix[sa[i]],suffix[sa[i-1]])\)

任意两个后缀的最长公共前缀?设为后缀 \(x\) 和后缀 \(y\)，其中

\(rank[x] < rank[y]\)。答案就是

\[\min_{(rank[x],rank[y]]}{height[i]} \]

如果已经求出了\(height\),用\(ST\)表就可以\(O(n \: log_2 n)\)预处理，

\(O(1)\)回答两个后缀的最长公共前缀.

对于\(height\)数组:

有性质\(:height[rank[i]] ≥ height[rank[i-1]]-1\)

如果 \(height[rank[i-1]] = 0\) 显然成立，否则在 \(i-1\) 这个后

缀与它前驱的 \(LCP\) 的基础上去掉第一个字符，就找到了一个后

缀与 \(i\) 这个后缀的 \(LCP≥ height[rank[i-1]]-1\).

进而有 \(height[rank[i]] ≥ height[rank[i-1]]-1\)

于是按照原串的顺序求 \(height\) 就能做到线性了.

以上内容来自\(R\)爷.(我还是不太懂的...放在这里是为了以后方便复习.)

所以代码长这样:

for (int i = 1 , j = 0 ; i <= n ; ++ i) {
    if ( rk[i] == 1 ) continue ;
    while ( s[i+j] == s[SA[rk[i]-1]+j] ) ++ j ;
    h[rk[i]] = j ; if ( j ) -- j ;
}

至于例题,\(UOJ\)和洛谷上都有大量板子题.