后缀数组

后缀数组

先下几个常见的定义

\(s(i, j)\)表示\([i, j]\)形成的连续子串

\(suf[i]\)表示以\(i\)为开头的后缀

\(rank\)数组：\(rank[i]\)表示将\(1\sim n\)的后缀排序后，\(suf[i]\)的排名

\(sa\)数组：\(sa[i]\)表示将\(1 \sim n\)的后缀排序后，排第\(i\)的在哪里

举个例子：

sort(a + 1, a + n + 1, cmp);

当我们采用上述代码之后，\(a\)数组存下的实际就是排第\(i\)的在哪里

---

\(sa\)数组不会相同，因为后缀的长度互不相同

在假想状态下，我们考虑在字符串的某尾加上无限个\(0\)

这样子，我们可以使得两个后缀具有相同的长度，便于比较

比如字符串"\(abaa\)"

我们实际上是在比较这4个字符串的排名：

\(abaa，baa0，aa00，a000\)

---

先看一个有趣的事情：
对于字符串\(S = S_1 + S_2, T = T_1 + T_2\)，且\(|S_1| = |S_2|, |T_1| = |T_2|\)
如果\(S_1 < T_1\)，那么\(S < T\)
如果\(S_1 = T_1\;and\;S_2 < T_2\)，那么\(S < T\)

---

这要怎么利用呢？

也就是说，我们现在把所有的后缀都看做是长度为\(n\)的字符串

我们先处理出所有的\(s(i, i)\)的字典序排名，如果不存在\(s(i, i) = s(j, j)\)，那么我们的序排好了

否则，我们可以利用所有的\(s(i, i)\)，按照上面的排序方式，得出所有的\(s(i, i + 2^1 - 1)\)的字典序排名

同样，如果不存在\(s(i, i + 2^1 - 1) = s(j, j + 2^1 - 1)\)，那么我们的序就排好了

否则，合并出\(s(i, i + 2^2 - 1)\)，然后再去判断

依次类推

当我们合并到\(s(i, i + 2^k - 1)\;(2^k \geq n)\)时，我们一定能判断出字典序排名

如果合并的时候，我们的复杂度可以做到\(O(n \log n)\)，那么总体而言，就能做到\(O(n \log ^2 n)\)

如果合并的时候，我们能做到\(O(n)\)，那么总体而言，就能做到\(O(n \log n)\)

可以对着上面这张经典的图理解一下

---

在描述\(O(n \log n)\)的鬼畜写法之前，我们先来看看\(O(n \log^2 n)\)的写法

inline bool cmp(int x, int y) { return P[x] < P[y]; }
inline void Suffix_sort() {
    for(int i = 1; i <= n; i ++) sa[i] = i;
    for(int i = 1; i <= n; i ++) rk[i] = s[i];
    //初始化sa和rank
    for(int k = 1; k <= n; k <<= 1) {
        //倍增
        for(int i = 1; i <= n; i ++) 
            P[i] = make_pair(rk[i], rk[i + k]);
        //通过stl的pair+sort来实现双关键字排序
        sort(sa + 1, sa + n + 1, cmp);
        int tmp = 1; rk[sa[1]] = 1;
        for(int i = 2; i <= n; i ++)
            rk[sa[i]] = (P[sa[i]] == P[sa[i - 1]]) ? tmp : ++ tmp;
        //排完序之后，按照字典序的顺序对每个点重新计算rank
        if(tmp >= n) break;
        //如果当前的排名已经 >= n，代表不存在两个相同的量，也就是排完了
    }
}

（它在luogu上跑过了1000000）

请确保你在明白了\(O(n \log^2 n)\)的写法后，再继续往下阅读

我们只需要把上面的\(sort\)换成基数排序即可

基数排序原理十分的好懂，请自行了解

void sort(int *a, int n, int m) {
    for(int i = 1; i <= n; i ++) cnt[p2[i]] ++;
    for(int i = 1; i <= m; i ++) cnt[i] += cnt[i - 1];
    for(int i = 1; i <= n; i ++) b[cnt[p2[i]] --] = i;
    //b用来暂时存储对第二关键字排完序之后的结果
    for(int i = 0; i <= m; i ++) cnt[i] = 0;
    for(int i = 1; i <= n; i ++) cnt[p1[i]] ++;
    for(int i = 1; i <= m; i ++) cnt[i] += cnt[i - 1];
    for(int i = n; i >= 1; i --) a[cnt[p1[b[i]]] --] = b[i];
    //这里一定要倒叙枚举
    for(int i = 0; i <= m; i ++) cnt[i] = 0;
}

inline void Suffix_sort() {
    for(int i = 1; i <= n; i ++) sa[i] = i;
    for(int i = 1; i <= n; i ++) rk[i] = s[i];
    int m = 128; //m初始化为字符集的大小
    for(int k = 1; k <= n; k <<= 1) {
        for(int i = 1; i <= n; i ++) 
            p1[i] = rk[i], p2[i] = rk[i + k];
        sort(sa, n, m);
        int tmp = 1; rk[sa[1]] = 1;
        for(int i = 2; i <= n; i ++)
            rk[sa[i]] = 
            	(p1[sa[i]] == p1[sa[i - 1]] && p2[sa[i]] == p2[sa[i - 1]]) ? 
            		tmp : ++ tmp;
        if(tmp >= n) break;
        m = tmp;
    }
}

---

那么我们能不能进一步优化呢？

当然是可以的，可以发现上面代码中的\(rk, p1, p2\)数组其实只需要保留两个即可

并且，对第二关键字实际上并不需要基排，只需要调用上一次的\(sa\)数组就可以得到结果

然而经过测试，发现在\(10^6\)的数据下只有\(20ms\)的常数差距

因此实际上没有必要学习网上流传的写法...

---

经过这么一段长长的文字，你终于懂了后缀数组，但是给后缀排序有啥用呢？

我们需要引入一个更强大的数组

\(lcp(i, j)\)表示后缀\(i\)和后缀\(j\)的最长公共前缀

\(height\)数组，表示\(lcp(suf[sa[i]], suf[sa[i - 1]])\)，即字典序第\(i\)小和字典序第\(i - 1\)小的最长公共前缀

---

一个十分重要的性质
对于后缀\(suf[i]\)和\(suf[j]\)，满足\(lcp(i, j) = min(height[k])\;(k \in[rk[i] + 1, rk[j]])\)

---

考虑证明：

首先证明，\(lcp(i, j) \leq min(height[k])\;(k \in[rk[i] + 1, rk[j]])\)

我们记\(min(height[k]) = h\)

如果\(lcp(i, j) > h\)，那么对于\(k \in [rk[i] + 1, rk[j]]\)而言

我们记\(lcp(i, j) = L\)

由于\(k\)的排名处于\(i\)和\(j\)之间，并且\(i\)和\(j\)的前\(L\)都相同，必然有\(k\)包含\(L\)这个前缀

否则，\(k\)的排名由于在\(L\)之前就出现了不同，因此要么在\(i\)之前，要么在\(j\)之后

因此，有\(height[k] = L > h = min(height[k])\)

这不可能，因此\(lcp(i, j) \leq h\)

然后证明，可以取到上界

这是因为\(height[i] \geq h\)，可以看做\(suf[sa[i]]\)和\(suf[sa[i - 1]]\)至少有长为\(h\)的公共前缀

公共前缀满足传递性，因此可以取到上界

---

那么怎么求\(height\)数组呢？

如果暴力的求解，复杂度显然是\(O(n^2)\)的

我们可以很清楚的知道\(suf[sa[i]]\)和\(suf[sa[i - 1]]\)在字符串构成的联系不如\(suf[i]\)和\(suf[i - 1]\)的联系

毕竟，\(suf[i]\)和\(suf[i - 1]\)只相差了一个字符

那么，我们直接按照下标顺序来计算的时候，可以发现

---

我们记\(h[i]\)表示\(suf[i]\)和字典序排在它前面的最长公共前缀

那么\(h[i] \geq h[i - 1] - 1\)

比如现在正在求\(h[i]\)，排在\(i\)之前的后缀是\(suf[j]\)

后缀\(i\)为\(abc...\)，后缀\(j\)为\(aba...\)，那么\(h[i] = 2\)

求\(h[i + 1]\)时，由于\(h[i] \geq 1\;(h[i] = 0可以无视)\)

因此，去掉首字母的后缀\(i + 1\)为\(bc...\)，后缀\(j + 1\)为\(ba...\)

可以发现，\(j + 1\)还是保持排在\(i + 1\)的前面，不妨设排在\(i + 1\)前面的后缀为\(k\)

那么，一定有\(h[i + 1] = lcp(i + 1, k) \geq lcp(i + 1, j + 1) = h[i] - 1\)

---

和求后缀数组比起来，求\(height\)显得十分的简洁

void Solve() {
    for(int i = 1, k = 0; i <= n; i ++) {
        if(k) k --; //此时的k相当于h[i]，得到的新k相当于h[i] - 1
        int j = sa[rk[i] - 1];
        while(s[j + k] == s[i + k]) k ++;
        height[rk[i]] = k; // = h[i]
    }
}

由于每次求\(h[i]\)时，\(k\)指针都只会\(- 1\)，也就是增加\(1\)的势能

而每次\(k\)往前挪移的时候，都需要\(1\)的势能

那么，势能总量是\(O(n)\)的，也就是求\(height\)数组只需要\(O(n)\)的复杂度