📂学习笔记

🔖字符串

2024-07-03 22:13阅读: 147评论: 0推荐: 0

【学习笔记】浅谈后缀数组SA

后缀数组

算法介绍

后缀数组(suffix array, 简称 SA)，是一种强有力的字符串处理算法

能在优良的时间复杂度下解决大部分字符串问题

其核心思想就如它的名字——将字符串每个后缀按字典序排序，并记录下它的编号和排名

算法定义

在本篇文章中，字符串的下标一律从 $1$ 开始，长度为 $n$ ，即 $s[1...n]$

后缀数组主要涉及到 $2$ 个数组：

$sa[i]$ ：表示排名为 $i$ 的后缀的编号

$rk[i]$ ：表示后缀 $i$ 的排名

其中，后缀 $i$ 表示从下标 $i$ 开始到字符串末尾的后缀字符串
$s[i...n]$

性质： $\forall 1 \le i \le n, sa[rk[i]] = rk[sa[i]] = i$

显然，这条性质是正确的

排名为【后缀 $i$ 的排名】的后缀是 $i$

【排名为 $i$ 的后缀】的排名是 $i$

图例：

算法详解

暴力 $O(n^2\log n)$

最暴力的做法

对于每个后缀 $i$ ，截取它存下来

再 $sort$ 排序

空间复杂度 $O(n^2)$

排序 $O(n \log n)$ ，比较 $O(n)$

时间复杂度 $O(n^2\log n)$

暴力做法时空都会爆炸

倍增 $O(n\log^2n)$

对于这种每个字串长度较大的问题，不妨试试使用倍增的思想

依次处理从 $i$ 开始长度为 $2^k$ 的子串 ( $0 \le k \le \log_2{n}$ )

就可以处理出 $rk[i][k]$ 与 $sa[i][k]$

对于长度为 $1$ 的序列直接 $O(n\log n)$ 暴力排序即可
对于长度为（）的序列可以从 $k - 1$ 的部分转移过来

那如何转移呢？回忆一下字典序比较

对于两个字符串 $s1$ 和 $s2$ ，从头开始枚举 $i$

若 $s1[i] < s2[i]$ 则立刻返回 $s1 < s2$ ，不用继续比较，反之同理

若 $s1[i] = s2[i] (\forall i)$ ，那么这两个字符串的字典序相同

因为对于当前问题所有子串长度都为 $2^{k-1}$ ，所以就不考虑长度不同的了

回到本问题，现在已经知道了所有 $rk[i][k-1]$

那么显然对于 $rk[i][k]$ 可以通过 $rk[i][k-1]$ 和 $rk[i + 2^{k-1}][k-1]$ 转移

所以，可以将 $rk[i][k-1]$ 和 $rk[i+2^{k-1}][k-1]$ 作为第一、二关键字排序，便可以得到所有 $s[i...min(i+2^k-1,n)]$ 的排名。如果 $i + 2 ^ k - 1 > n$ ，也就是说这个子串不是完整的，那么将它的第二关键字设为无限小（最小），第一关键字和前面相同，延续上一次排序后的 $rk[i][k-1]$ 。然后，在sort一下即可

空间优化：因为每次只需 $k-1$ ，所以使用滚动数组，或用另一数组记录上一次求出的 $rk$ 即可;而每次的 $sa$ 都不会被用到，所以不用开第二维

复杂度倍增 $O(\log n)$ ，排序 $O(n\log n)$

所以复杂度为 $O(n\log^2n)$

代码就不放了，实现很简单，也不是主流做法。

对于 $n \ge 500000$ 时，就会爆炸了，所以还需要优化

图例：

倍增+基数排序 $O(n\log n)$

因为所有排名的值域不会超过 $n$ ，所以就可以使用基数排序代替sort达到复杂度少一个 $\log$ 。

基数排序是一种稳定的 O(值域) 的排序方法，通常在值域较小时使用

对于单关键字：直接用一个桶 $c$ 记录各值域的出现次数，将它做一个前缀和，这时 $c[i]$ 就是值域 $i$ 的排名了。但注意，每次查完值域 $i$ 的排名就要将它 - 1，因为相同值域可能有多个值。
对于多关键字，因为排序的优先级是从低关键字到高关键字的，要使当前关键字排序后不对后续产生影响，所以从高关键字到低关键字依次排序。如果从第一关键字开始排序的话，那最终的结果是按最后一个关键字优先的，所以只能采取依次从第 $k,k-1,k-2...1$ 关键字排序。

对于此算法，只需用双关键字，所以先将第二关键字基数排序，再排第一关键字即可。

举个例子：
将 $(1,1),(1,2),(2,1),(1,3),(2,2),(2,1)$ 从小到大排序

首先按第二关键字排序

所以，排名如下

排序结果： $(1,1),(2,1),(2,1),(1,2),(2,2),(1,3)$

再按第一关键字排序

所以，最终的排名为（按第一次排序后的编号）

排序结果： $(1,1),(1,2),(1,3),(2,1),(2,1),(2,2)$

常数优化

其实第二关键字不需要基数排序

对于长度超范围的，直接将其列入排序结果的首部（因为第二关键字为最小值）
对于在范围内的，按上一次更新完的 $sa$ 依次从下标 $1$ 到 $n$ 遍历，存在 $sa[i] - 2^k > 0$ 的，将 $sa[i] - 2 ^ k$ 放入排序结果（也就是当前的 $sa[i]$ 为以 $sa[i]-2^k$ 为第一关键字排序的第二关键字)。根据 $sa$ 的定义，按顺序遍历 $sa$ 取出的结果就是已经从小到大排过序的（ $sa[i]$ 为第 $i$ 名的编号），所以可以证明它的正确性。

这样的做法是严格 $O(n)$ 的，比一次基数排序的常数小一点

对于不同的排名等于 $n$ 时，可直接结束

不断倍增下去时实际上是使这个排名越来越精准，不出现重复。

但如果当前已经是不重复的了，就没必要继续倍增下去。

代码

这是 P3809 模板题的代码

#include <bits/stdc++.h>
#define int long long
using namespace std;
namespace fastio{
    template<typename T> inline void read(T &t){
        int x = 0, f = 1;
        char c = getchar();
        while(!isdigit(c)){
            if(c == '-') f = -f;
            c = getchar();
        }
        while(isdigit(c)) x = x * 10 + c - '0', c = getchar();
        t = x * f;
    }
    template<typename T, typename ... Args> inline void read(T &t, Args&... args){
        read(t);
        read(args...);
    }
    template<typename T> void write(T t){
        if(t < 0) putchar('-'), t = -t;
        if(t >= 10) write(t / 10);
        putchar(t % 10 + '0');
    }
};
using namespace fastio;
const int N = 1e6 + 5;
char s[N];
int n, m = 130, x[N], y[N], c[N];//x即rk
int sa[N];
void SA(){
    for(int i = 1; i <= n; ++i) c[x[i] = s[i]]++;
    for(int i = 1; i <= m; ++i) c[i] += c[i-1];
    for(int i = n; i >= 1; --i) sa[c[x[i]]--] = i;
    //对长度为1的基数排序
    for(int k = 1; k <= n; k <<= 1){
        int p = 0;
        for(int i = n - k + 1; i <= n; ++i) y[++p] = i;
        for(int i = 1; i <= n; ++i){
            if(sa[i] > k){
                y[++p] = sa[i] - k;
            }
        }
        //第二关键字无需基数排序
        for(int i = 1; i <= m; ++i) c[i] = 0;
        for(int i = 1; i <= n; ++i) c[x[y[i]]]++;
        for(int i = 1; i <= m; ++i) c[i] += c[i-1];
        for(int i = n; i >= 1; --i) sa[c[x[y[i]]]--] = y[i];
        //对第一关键字基数排序
        y[sa[1]] = 1, p = 1;
        //将x设为旧的rk，y为新的rk，最后再调换回来，节省空间
        for(int i = 2; i <= n; ++i){
            y[sa[i]] = (x[sa[i]] == x[sa[i-1]] && x[sa[i] + k] == x[sa[i-1] + k] ? p : ++p);
        }
        swap(x, y);
        if(p >= n) break;
        //如果排名都不相同，就可以不用继续了
        m = n;
    }
}
signed main(){
	scanf("%s", s + 1);
	n = strlen(s + 1);
	SA();
	for(int i = 1; i <= n; ++i) cout << sa[i] << ' ';
	return 0;
}