【字符串】后缀数组SA

后缀数组

概念

实际上就是将一个字符串的所有后缀按照字典序排序

得到了两个数组 \(sa[i]\) 和 \(rk[i]\)，其中 \(sa[i]\) 表示排名为 i 的后缀，\(rk[i]\) 表示后缀 i 的排名

注意到 \(rk\) 和 \(sa\) 是互逆的，即 \(sa[rk[i]]=rk[sa[i]]=i\)

先讨论几个关于 \(lcp\) 的性质，令 \(lcp(i,j)\) 表示 \(sa[i]\) 和 \(sa[j]\) 的最长公共前缀

1. \(lcp(l,r)=min(lcp(l,i),lcp(i,r)),l\le i\le r\)，注意这里只需要枚举任意一个 i 即可

   证明：

   令 \(p=min(lcp(l,i),lcp(i,r)),sa[l]=u,sa[r]=v,sa[i]=w\)

   由于 \(u\) 和 \(w\) 的前 \(p\) 位相同，\(v\) 和 \(w\) 的前 \(p\) 位相同

   所以 \(u\) 和 \(v\) 的 \(lcp\) 至少为 \(p\)

   假设 \(u\) 和 \(v\) 的 \(lcp>p\)，不妨设其为 \(q=p+k\)

   我们知道 \(u[q]\neq w[q],v[q] \neq w[q]\)，并且 \(w[q]\ge u[q],v[q]\ge w[q]\)

   那么 \(w[q]\) 只能是 \(>u[q]\)，且 \(v[q]\) 只能是 \(>w[q]\)，所以 \(u[q]\) 不可能等于 \(v[q]\)

2. \(lcp(l,r)=min_{i=l+1}^rlcp(i,i-1)\)

   证明：

   注意到 \(lcp(l,r)=min(lcp(l,l+1),lcp(l+1,r))\)

   递归运算即可得到上式

根据这两个数组我们能得到 \(H\) 数组，\(H[i]\) 表示 \(sa[i]\) 和 \(sa[i-1 ]\) 的最长公共前缀的长度

\(H\) 有两个性质

1. \(H[rk[i]]\ge H[rk[i-1]]-1\)

   证明：

   令 \(suf[k]\) 为排名正好在 \(suf[i-1]\) 前一个的后缀，那么它们的公共前缀的长度就是 \(H[rk[i-1]]\)

   注意到 \(su f[k+1]\) 的排名一定在 \(suf[i]\) 之前，而 \(suf[k+1]\) 和 \(suf[i]\) 的最长公共前缀至少是 \(H[rk[i-1]]-1\)

   所以 \(H[rk[i]]\ge H[rk[i-1]] - 1\)

2. 后缀 \(x\) 和 \(y\) 的最长公共前缀为 \(\min_{i=rk[x]+1}^{rk[y]}H[i]\)，实际上这就是 \(lcp\) 的第二个性质

3. \(sa[i]\) 与 \(sa[1]\) 到 \(sa[i-1]\) 的最长公共前缀是与 \(sa[i-1]\) 的最长公共前缀

实际应用中求 \(sa\) 的方法就是倍增了 = =，具体实现原理就不写了 = =

#include<iostream>
#include<cstdio>
#include<cstring>
#define maxn 1000010
using namespace std;

int n, m;

char s[maxn];

int tax[maxn], tp[maxn], sa[maxn], rk[maxn], M = 122;
void rsort() { // tp[i] 表示排序时第二关键字为 i 的后缀是什么
    // rsort 的实际作用就是按照 rk[i] 为第一关键字，tp[i] 为第二关键字从小到大排序
    for (int i = 0; i <= M; ++i) tax[i] = 0;
    for (int i = 1; i <= n; ++i) ++tax[rk[i]];
    for (int i = 1; i <= M; ++i) tax[i] += tax[i - 1];
    for (int i = n; i; --i) sa[tax[rk[tp[i]]]--] = tp[i];
}

int c1, H[maxn]; // c1 表示不同的 rk[i] 有多少个，当 c1 == n 时，排序完毕
void SA() {
    if (n == 1) return (void) (sa[1] = rk[1] = 1);
    for (int i = 1; i <= n; ++i) rk[i] = s[i], tp[i] = i; rsort();
    for (int k = 1; k < n; k *= 2) { // k 是已经排序完毕的长度
        if (c1 == n) break; M = c1; c1 = 0; // c1 清零之后就暂时当做计数器用了
        for (int i = n - k + 1; i <= n; ++i) tp[++c1] = i;
        for (int i = 1; i <= n; ++i) if (sa[i] > k) tp[++c1] = sa[i] - k; // 更新 tp 数组
        rsort(); // 在进行这个 rsort 之前，sa 和 rk 排序的长度依旧是 k
        // rsort 结束之后，sa 得到了更新，所以下面的操作是更新 rk
        swap(rk, tp); rk[sa[1]] = c1 = 1; // 这时候的 tp 变成了上一轮的 rk，c1 是计数器同时是不同的 rk[i] 的个数
        for (int i = 2; i <= n; ++i) {
            if (tp[sa[i - 1]] != tp[sa[i]] || tp[sa[i - 1] + k] != tp[sa[i] + k]) ++c1;
            // 如果排名为 i - 1 和排名为 i 的串的前 k 位相同，并且前 2k 位也相同，那么这两个串的排名就暂时相同了
            rk[sa[i]] = c1;
        }
    } int lcp = 0;
    for (int i = 1; i <= n; ++i) {
        if (lcp) --lcp;
        int j = sa[rk[i] - 1];
        while (s[j + lcp] == s[i + lcp]) ++lcp;
        H[rk[i]] = lcp;
    }
}

int main() {
    scanf("%s", s + 1); n = strlen(s + 1); SA();
    for (int i = 1; i <= n; ++i) printf("%d ", sa[i]);
    return 0;
}

应用

单个字符串

1. 可重叠最长重复子串

   定义：对于一个串，如果它的一个子串在原串中出现出现至少两次，则称这个子串是一个重复子串

   可重叠指两次出现的位置可以重叠

   直接求 \(H\) 的最大值即可

   证明：同理，一个子串一定是某一个后缀的前缀

   所以原问题相当于求两个后缀的最长公共前缀的最大值，这个东西显然就是 \(H\) 的最大值

2. 可重叠重复子串计数

   求有多少本质不同的子串出现至少两次

   再次重申，子串 = 某一个后缀的一个前缀

   我们考虑将所有后缀按照字典序加入，我们求没加入一个后缀对答案贡献多少

   首先他所贡献的重复的子串为 \(H[i]\)，但是有一些已经被记过数了

   所以我们考虑去重

   以下开始胡扯 不知道给怎么说了

   给个答案吧 \(ans=\sum_{i=1}^nmax(H[i]-H[i-1],0)\)

   不过讲道理，这个东西 \(SAM\) 随便做

3. 不可重叠最长重复子串

   注意到 \(H\) 这个东西是极大的，考虑二分答案 x

   那么我们考虑如果固定一个 \(sa[i]\)，那么排名在 \(sa[i ]\) 前面的，且与 \(sa[i]\) 的最长公共前缀的大小至少为 \(x\)，且与 \(sa[i]\) 的位置相差至少为 \(x\)（要不然就重合了

   假设这个串为 \(sa[j]\)，注意到因为 \(H\) 这个东西是极大的，所以 \(sa[i]\) 与 \(sa[j+1]\) 到 \(sa[i-1]\) 这些串的最长公共前缀都至少为 \(x\)，实际上 \(H[j+1]\) 到 \(H[i]\) 都至少为 \(x\)

   upd：那么反过来就是如果 \(H[j+1]\) 到 \(H[i]\) 都大于等于 \(x\)，那么 \(sa[i]\) 和 \(sa[j]\) 的 \(lcp\) 至少为 \(x\)

   这启示我们将 \(H\) 按照二分的 \(x\) 分组，也就是说 \(\ge x\) 且连续的 \(H\) 分一组，如果某一组里的后缀的位置的最大值 - 最小值 \(\ge x\)，则表示二分的这个值合法

4. 可重叠的 \(k\) 次最长子串

   同样二分答案，只不过判断的是否有一个组的个数大于等于 \(k\)

   按照 3 的思路，我们发现只需要求每一个 \(H\) 的每一个 \(k-1\) 区间的最小值即可

   显然可以单调队列维护

5. 本质不同的子串的个数

实际上就是求所有后缀有多少本质不同的前缀

我们考虑按照将所有后缀按照字典序排序，那么每次新加进来的一个后缀的前缀的个数为 \(n-sa[i]+1\)，但是与前面的所有后缀重复的前缀有 \(H[i]\) 个，因为 \(H\) 是极大的

答案即为 \(\sum_{i=1}^nn-sa[i]+1-H[i]\)

1. 重复出现次数最多的连续重复子串

   我们考虑枚举连续重复子串的长度 \(l\)，然后我们将串分成 \(\lfloor\frac{n}{l}\rfloor\) 块

   求出相邻两块的 \(lcp\) 的长度 \(k\)，那么出现次数为 \(k/l+1\)

   注意还要检查一下块前面的一部分是否可以加进去

   时间复杂度为 \(O(n\log n)\)

两个字符串

1. 两个串的最长公共子串

   将两个串之间用没有出现过的字符拼接起来

   然后直接后缀排序，注意到不会有任何一个 \(H[i]\) 能够跨越未知字符

   如果 \(sa[i]\) 和 \(sa[i-1]\) 不是同一个串的后缀，那么可以拿 \(H[i]\) 来更新答案

   容易知道最大值一定是取在某个 \(sa[i]\) 和 \(sa[i-1]\)

   upd：为啥我现在不知道了

   还是随便口胡一下吧

   因为至少有一个 \(sa[i]\) 和 \(sa[i-1]\) 是分别属于不同串的后缀的

   如果只有一个的话，那么这个 \(H[i]\) 就是答案，因为 \(H\) 是极大的

   如果有多个的话，就取最大值好了

   或者换个说法如果最终答案是 \(sa[i]\) 和 \(sa[j]\) 的 \(lcp\)，且 \(i\) 和 \(j\) 不相邻

   那么 \(H[j+1]\) 到 \(H[i]\) 都是至少有这么大的，中间一定有一对 \(sa[k]\) 和 \(sa[k+1]\) 不属于同一个串的后缀

2. 长度不小于 \(k\) 的公共子串个数

题目列表：

LuoguP2408

LuoguP2852

LuoguP4051

SP1811

LuoguP4248