后缀数组（SA）

目录

• 后缀数组（SA）
• 做法
• $\mathcal O(n^2 \log n)$ 做法
• $\mathcal O(n \log^2 n)$ 做法
• $\mathcal O(n \log n)$ 做法
• $\mathcal O(n)$ 做法
• 应用
• 循环同构问题
• 在字符串 $s$ 中找子串 $t$（在线）
• 从字符串首尾取字符最小化字典序
• height 数组
• height 数组的应用
• 两子串最长公共前缀
• 比较一个字符串的两个子串大小关系
• 不同子串数量
• 出现至少 k 次的子串的最大长度
• 参考文献

回到顶部

后缀数组（SA）

感觉会有很多写错或写不清楚的地方，读者发现问题可以评论或右侧 QQ 联系我，感谢！

约定

“ 后缀 $i$ ” 表示以第 $i$ 个字符开头的后缀。

$a[i]$ 表示字符串 $a$ 的第 $i$ 位，$a[l, r]$ 表示 $a$ 中位置 $l \sim r$ 的子串。

一个字符串从第 $1$ 位开始，第 $n$ 位结束。

两个字符串的大小关系定义如下：

1. $a$ 与 $b$ 为同一字符串，则 $a = b$。

2. $a$ 是 $b$ 的真前缀，则 $a < b$。

3. 若不满足 1.2. 则一定存在最小的 $i$ 满足 $a[i] \not = b[i]$ 则 $a, b$ 的大小关系由 $a[i]$ 和 $b[i]$ 的大小关系确定。

定义

后缀数组主要求两个数组：$sa$ 和 $rk$。

其中，$sa[i]$ 表示将所有后缀排序后第 $i$ 小的后缀编号，$rk[i]$ 表示后缀 $i$ 的排名，简单来说，$sa[i]$ 表示排名 $i$ 的是谁，$rk[i]$ 表示后缀 $i$ 排名第几。

显然，这两个数组满足 $rk[sa[i]]=sa[rk[i]]=i$。以下是一个 $sa$ 和 $rk$ 的例子：

做法

$\mathcal O(n^2 \log n)$ 做法

把所有后缀处理出来，用 sort 进行排序，每次比较为 $\mathcal O(n)$ 则总时间复杂度为 $\mathcal O(n^2 \log n)$。

$\mathcal O(n \log^2 n)$ 做法

需要用到倍增思想。令 $rk_w[i]$ 表示 $\forall x\in[1, n], s[x, \min(x + w - 1, n)]$ 中 $s[i, \min(i + w-1, n)]$ 的排名，则对于 $rk_{2w}[i]$ 我们可以通过以 $rk_w[i]$ 为第一关键字，$rk_w[i + w]$ （$i+w>n$ 则视为无穷小）为第二关键字，进行排序即可求出 $rk_{2w}[i]$ 的值。求出所有后缀排名会进行以上操作 $O(\log n)$ 次，若使用 sort 进行排序则每次排序 $\mathcal O(n\log n)$ ，则时间复杂度为 $\mathcal O(n\log^2 n)$。

以下为倍增示意图：

$\mathcal O(n \log n)$ 做法

发现瓶颈是排序，如果能做到 $\mathcal O(n)$ 排序，就能做到 $\mathcal O(n \log n)$ 了，考虑到排序的值域为 $\mathcal O(n)$，并且是一个双关键字的排序，所以我们可以使用基数排序将排序优化到 $\mathcal O(n)$。

这里介绍一下基数排序。

基数排序的原理是将待排序的元素拆分为 $k$ 个关键字，以此以 $k$ 关键字、$k - 1$ 关键字、……、$1$ 关键字进行排序，最后就能得到排序后的结果，以下是一个例子：

如果以计数排序为每次关键字排序的内层排序，则时间复杂度为 $\mathcal O(kn + \sum\limits_{i=1}^k w_i)$ 其中，$w_i$ 为第 $i$ 层关键字的值域。

对应到倍增做法中的排序，$k=2$，$w_1, w_2$ 为字符集大小，则排序复杂度则可看作 $\mathcal O(n)$，故最终后缀排序就可以做到 $\mathcal O(n \log n)$。

#include <bits/stdc++.h>
const int N = 1e6 + 10;
char s[N]; int n, m, k;
int cnt[N], sa[N], sec[N], rk[N];

inline void Csort()
{
	for (int i = 1; i <= m; ++ i)
		cnt[i] = 0;
	// 清零桶
	for (int i = 1; i <= n; ++ i)
		cnt[rk[i]] ++;
	// 将第一关键字压入桶中
	for (int i = 2; i <= m; ++ i)
		cnt[i] += cnt[i - 1];
	// 记个前缀和方便求排名
	for (int i = n; i >= 1; -- i)
		sa[cnt[rk[sec[i]]] --] = sec[i];
	// 对于第一关键字相同的数对来说
	// 其排名区间已经确定，我们只需通过第二关键字来确定其特定的排名
	// 我们从后到前枚举第二关键字的排名，则此时对应数对的排名就是对应排名区间的最后一个
	// 再将对应排名区间的右区间 -1 
	// 表示接下来枚举到的 第一关键字 相同的数对的排名区间改变了
}

int main()
{
	scanf("%s", s + 1);
	n = strlen(s + 1), m = 'z';
	// n, m 分别代表 s 长度以及字符集大小

	for (int i = 1; i <= n; ++ i)
		sec[i] = i, rk[i] = s[i];
	// sec[i] 表示第二关键字排名为 i 的编号
	// 初始时并无第二关键字，所以按照顺序排序
	// rk[i] 表示第一关键字中编号为 i 的排名
	// 初始时即为 s[i] 的字符大小
	// sa[i] 表示排名为 i 的编号

	// 需要注意，rk[i] 中相同串的排名会相同
	// sa[i] 中相同的串排名不会相同，会根据位置来具体排名（越靠前排名越前）
	Csort();

	for (int w = 1; w <= n; w *= 2)
	{
		// w 为当前倍增到的长度
		int num = 0;
		for (int i = n - w + 1; i <= n; ++ i)
			sec[++ num] = i; 
		// [n - w + 1, n] 无第二关键字，故令其关键字排名靠前
		for (int i = 1; i <= n; ++ i)
			if (sa[i] > w) sec[++ num] = sa[i] - w;
		// 从小到大枚举排名，判断此时这个串是否能作为其他串的第二关键字
		// 若能作为其他串的第二关键字，则对应编号为 sa[i] - w
		Csort(); std::swap(sec, rk); num = 0;
		// 第一第二关键字都已经求出，进行基数排序即可
		// 基数排序之后，sa 数组已经求出，我们需要用其更新 rk 数组
		// sec 数组已经没用，rk 数组需要更新，暂时用 sec 储存 rk 数组
		for (int i = 1; i <= n; ++ i)
			rk[sa[i]] = (sec[sa[i]] == sec[sa[i - 1]] 
				&& sec[sa[i] + w] == sec[sa[i - 1] + w]) ? num : ++ num;
		// 按照第一关键字排名从小到大枚举
		// 依次更新 rk 数组
		m = num;
		// 更新关键字值域大小
	}
	for (int i = 1; i <= n; ++ i)
		printf("%d ", sa[i]);
	return 0;
}

$\mathcal O(n)$ 做法

有 SA-IS 和 DC3 做法，这里暂不介绍（一般用不到）。

应用

循环同构问题

循环同构：当字符串 $s$ 中可以选定一个位置 $i$ 满足：$s[i,n] + s[1,i - 1] = t$ ，则称 $s$ 与 $t$ 循环同构，例如 $\mathtt{abcdd}$，与这个字符串循环同构的串有 $\mathtt{abcdd}$、$\mathtt{bcdda}$、$\mathtt{cddab}$、$\mathtt{ddabc}$、$\mathtt{dabcd}$，

给出一个字符串，我们需要知道与其字符串循环同构的串的排名。Link

将字符串 $s$ 复制一份成 $ss$，求其后缀数组即可。

在字符串 $s$ 中找子串 $t$（在线）

在线的含义是 $s$ 给出，$t$ 只在询问时给出。

将 $s$ 的后缀数组求出，在其后缀数组中二分寻找 $t$（是否存在），$q$ 组询问，时间复杂度 $\mathcal O(|s| \log |s| + q \times |t| \log |s|)$，当然，想找出 $t$ 在 $s$ 中所有出现的位置也是可以做的，但是 KMP 显然可以做到更优。

从字符串首尾取字符最小化字典序

给你一个字符串，每次从首或尾取一个字符组成字符串，问所有能够组成的字符串中字典序最小的一个。Link

一个简单的想法是暴力 $\mathcal O(n)$ 判断选首还是选尾，这样最差是 $\mathcal O(n ^2)$ 的，我们考虑将反串拼接在原串后，中间加个从未出现过的字符，这样，就可以 $\mathcal O(1)$ 判断选首还是选尾，就能 $\mathcal O(n\log n)$ 解决此题。

height 数组

LCP：两个字符串 $s, t$ 的 LCP 表示最长相同前缀。

下文的 $\operatorname {lcp}(l, r)$ 表示 $s[l, n]$ 与 $s[r, n]$ 的 LCP。

height 数组定义如下：

$$\operatorname {height}[x]=\begin{cases}\operatorname{lcp}(sa[x], sa[x - 1])&x > 1\\0&x=1\end{cases}$$

height 数组可以 $\mathcal O(n)$ 求出，需要一个引理：$\operatorname{height}[rk[i]] \geq \operatorname{height}[rk[i - 1]] - 1$

证明如下：

1. 若 $\operatorname{height}[rk[i - 1]] \leq 1$，上述式子显然成立，因为 $\operatorname{height}[rk[i - 1]] - 1 \leq 0$。
2. 若 $\operatorname{height}[rk[i - 1]] > 1$，令后缀 $i-1$ 为 $aBC$（$B$ 长度为 $\operatorname{height}[rk[i - 1]]-1$，后面会用到），则后缀 $i$ 为 $BC$，后缀 $sa[rk[i-1]-1]$ 为 $aBD(D < C)$，我们可以推出后缀 $sa[rk[i-1]-1]+1=BD$，则后缀 $sa[rk[i-1]-1]+1$ 一定排在 $i$ 之前，故 $\operatorname {lcp}(i, sa[rk[i] - 1]) \geq |B|=\operatorname{height}[rk[i - 1]]-1 \Rightarrow \operatorname {height}[rk[i]] \geq \operatorname{height}[rk[i - 1]]-1$。

int LstHeight = 0;
for (int i = 1; i <= n; ++ i)
{ 
    // 按照 rk 从小到大求
	if (LstHeight) LstHeight --;
    // 从上一个状态继承下来
	while (s[sa[rk[i]] + LstHeight] == s[sa[rk[i] - 1] + LstHeight])
		LstHeight ++; // 求出对应的 height
	height[rk[i]] = LstHeight;
}

height 数组的应用

两子串最长公共前缀

给出一个定理：

$$\operatorname {lcp}(sa[l], sa[r])=\min_{i=l+1}^r \operatorname {height}[i]$$

要证明这个定理，我们首先证明一个引理：

​ 对于任意的 $1 \leq l < k < r \leq n$，$\operatorname {lcp}(sa[l], sa[r])=\min \{\operatorname {lcp}(sa[l], sa[k]), \operatorname{lcp}(sa[k], sa[r]) \}$

证明如下：

1. 设 $p=\min \{\operatorname {lcp}(sa[l], sa[k]), \operatorname{lcp}(sa[k], sa[r]) \}$，则有 $\operatorname {lcp}(sa[l], sa[k]) \geq p,\operatorname{lcp}(sa[k], sa[r])\geq p \Rightarrow$ $s[sa[l], sa[l] + p-1]=$ $s[sa[k], sa[k]+p-1] = s[sa[r], sa[r] + p-1]$，可以得到结论 $\operatorname {lcp}(sa[l], sa[r]) \geq p$。
2. 再设 $\operatorname {lcp}(sa[l], sa[r]) =q > p$，则有 $s[sa[l], sa[l] + q - 1] = s[sa[r], sa[r] + q - 1]$，由于 $p=\min \{\operatorname {lcp}(sa[l], sa[k]), \operatorname{lcp}$ $(sa[k], sa[r]) \}$，故 $s[sa[l] + p - 1 + 1] \not=$ $s[sa[k] + p - 1 + 1]$ 或 $s[sa[r] + p - 1 + 1] \not= s[sa[k] + p - 1 + 1]$，令 $x=s[sa[l] + p - 1 + 1],y=s[sa[k]+p-1+1],z=s[sa[r] + p - 1 + 1]$，因为 $l < k < r$ 所以 $x \leq y \leq z$，又考虑到 $q > p \Rightarrow x=z \Rightarrow x=y=z$ 与上文矛盾，故 $q > p$ 不成立，可以得到结论 $\operatorname {lcp}(sa[l], sa[r])\leq p$。

由 1. 2. 可得：对于任意的 $1 \leq l < k < r \leq n$，$\operatorname {lcp}(sa[l], sa[r])=\min \{\operatorname {lcp}(sa[l], sa[k]), \operatorname{lcp}(sa[k], sa[r]) \}$

有了这个引理，证明上文的定理就很容易了，证明如下：

1. 当 $r - l = 1$ 或 $r-l=2$ 时，显然成立。
2. 设 $r-l=m$ 时成立，当 $r-l=m+1$ 时，由引理可知 $\operatorname{lcp}(sa[l], sa[r])=\min\{\operatorname{lcp}(sa[l], sa[l + 1]), \operatorname{lcp}(sa[l + 1], sa[r])\}$ 考虑到 $r-(l+1) = m\leq m$ 所以有 $\operatorname{lcp}(sa[l], sa[r])=\min\{\operatorname{lcp}(sa[l], sa[l + 1]), \min\limits_{i=l+2}^r \operatorname {height}[i])\}=\min\limits_{i=l+1}^r \operatorname {height}[i]$，根据数学归纳法，上述定理成立。

有了这个定理，求任意子串的 LCP 就可以转化为 RMQ 问题。

比较一个字符串的两个子串大小关系

需要比较的是 $s[a, b]$ 和 $s[c, d]$ 的大小关系。

1. 若 $\operatorname {lcp} (a, c) \geq \min \{ b-a+1,d-c+1\}$，则两者的大小关系由长度关系得到，即 $b-a+1<d-c+1 \Leftrightarrow s[a, b] < s[c, d]$。
2. 否则，两者的大小关系由 $rk$ 数组确定，即 $rk[a] < rk[c] \Leftrightarrow s[a, b] < s[c, d]$。

不同子串数量

考虑容斥，子串我们看作后缀的前缀（非常常见的套路），总子串个数为 $\dfrac{n \times (n-1)}{2}$，如果按照后缀排序的顺序枚举后缀，每次新增的子串就是除了与上一个后缀的 LCP 剩下的前缀，也就是说，容斥要减去的就是当前的 height 数组。

所以，不同子串数量为：

$$\dfrac{n \times (n-1)}{2} - \sum_{i=2}^n \operatorname{height}[i]$$

出现至少 k 次的子串的最大长度

出现至少 $k$ 也就代表着后缀排序之后，至少连续 $k$ 个后缀的 LCP 含有这个子串，所以，求出 height 数组之后，找出每相邻的 $k-1$ 个 height 数组的最小值的最大值，单调队列 $\mathcal O(n)$ 即可（瓶颈在求后缀数组 $\mathcal O(n\log n)$，故用线段树啥的也行）。

参考文献

1. oi-wiki
2. [2004]后缀数组 by. 徐智磊
3. [2009]后缀数组——处理字符串的有力工具 by. 罗穗骞