字符串处理-SA数组

Evan_song1234

已于 2022-11-07 10:15:54 修改

阅读量279

点赞数

分类专栏：算法与数据结构文章标签：算法

于 2021-11-05 18:46:23 首次发布

本文链接：https://blog.csdn.net/Evan_song1234/article/details/121168668

版权

算法与数据结构专栏收录该内容

24 篇文章 2 订阅

订阅专栏

后缀数组 $\tt SA$ 可以用于各方面字符串问题，其目的是求出这个字符串的所有后缀的按照字典序的排名。

前置知识

倍增 / DC3

算法用途

可以用来求最长公共子串，最长回文串等

算法复杂度

字符串长度为 $\tt n$

时间

$\tt O(n\log n)$

空间

$\tt O(n)$

算法实现

要知道，最暴力算法就是把所有后缀找出来，然后用 $\tt sort$ 排序

虽然时间复杂度和这个算法的优化版本一样 $\tt O(n\log n)$ ，但是这个算法的空间却是 $\tt O(n^2)$ 的。很容易炸。

后缀数组需要求两个数组：后缀数组 $\tt SA$ 和排名数组 $\tt rank$

$\tt SA_i$ 代表从第 $\tt i$ 个字符开始的后缀的排名。

$\tt rank_i$ 代表排名为 $\tt i$ 的后缀的开始字符的下标。

所以，其实 $\tt SA_i = j$ 时， $\tt rank_j = i$ 。

对于后缀数组的实现，主要有两种算法：

倍增算法
DC3算法

我在这只讲倍增（~~主要是DC3我不会~~）。

倍增算法的思路主要是递推，

我们先求出每个后缀按照第一个字符的排序的 $\tt rank$ （若第一个字符相同，则 $\tt rank$ 相等），

即每个 i 对应的 $S_{[i, i]}$ 在所有 $S_{[i, i]}$ 中的排名。

然后用所得出的 $r ank$ 来计算出所有后缀按照前两个字符排序的 $\tt rank$ （每个 $\tt i$ 对应的 $\tt S_{[i, i+2^0]}$ 在所有 $\tt S_{[i, i +2^0]}$ 中的排名。）

接着是四个，八个…，直到全部字符。（每个 $\tt i$ 对应的 $\tt S_{[i, i+2^k]}$ 在所有 $\tt S_{[i, i +2^k]}$ 中的排名。）

过程如下：

假设我们要计算后缀按照前 $\tt 2^k$ 个字符排序的 $\tt rank$ 。而我们已经求出了按前 $\tt 2^{k-1}$ 个字符排序的 $\tt rank$ 。

那么对于每个 $\tt p$ ，我们要求的就是 $\tt S_{[p, p+2^{k}]}$ 在所有 $\tt S_{[i, i+2^{k}]}$ 的排名。

于是我们要考虑如何用 $\tt S_{[i, i + 2^{k-1}]}$ 来表示 $\tt S_{[p, p+2^{k}]}$ 。

发现 $\tt S_{[p, p+2^{k}]} = S_{[p, p+2^{k-1}]} + S_{[p+2^{k-1}+1, p+2^{k}]}$ 。

而 $\tt S_{[p, p+2^{k-1}]}$ 和 $\tt S_{[p+2^{k-1}+1, p+2^{k}]}$ 的排名我们都已经求过了。

即 $\tt rank_p$ ， $\tt rank_{p + 2^{k-1} +1}$ 。

我们把所有 $\tt rank_{i}$ 和 $\tt rank_{i + 2^{k-1} +1}$ 合并形成 $\tt n$ 个二元组。

然后对于这个二元组排序，于是就可以得出新的 $\tt rank_i$ 。

重复这个步骤，直到所有 $\tt rank_i$ 都不相同为止。然后求出来的 $\tt rank$ 就是我们要求的排名数组的。

这时候，我们最多需要 $\tt\log n$ 次求 $\tt rank$ ，每次求需要 $\tt O(n\log n)$ 的快速排序时间，所以总时间复杂度是 $\tt O(n\log^2n)$ 。

算法应用

最长公共前缀（LCP）

$\tt SA$ 数组还有一种基本操作，给两个后缀的开始字符串，求他们最长公共前缀长度。

我们可以快速求出排序后相邻两个字符串的最长公共前缀的长度。

我们让 $\tt height_i$ 代表 $\tt SA_{i - 1}$ 和 $\tt SA_i$ 代表的两个后缀字符串的最长前缀的长度。

然后，我们可以得到两个后缀的排名 $\tt rank_i, rank_j$ ，然后我们只需要求出 $\tt \min_{i+1\leq x\leq j}(height_i)$

怎么求？只需要预处理然后使用 $RMQ$ 就行了。

最长公共子串（LCS）

求 $\tt N$ 个串的最长公共子串

我们发现这个问题可以转化为求一些后缀的最长公共前缀的最大值，这些后缀应分属于 $\tt N$ 个串。

具体方法如下：

设 $\tt N$ 个串分别为 $\tt S_1,…, S_N$ ，首先建立一个串 $\tt S$ ，把这 $\tt N$ 个串用不同的分隔符连接起来。 $\tt S = S_1[P_1]S_2[P_2]S_3…S_{N-1}[P_{N-1}]S_N$ 。

这些分隔符应为 $\tt N-1$ 个不在字符集中的字符。

接下来，求出字符串 $\tt S$ 的后缀数组和 $\tt height$ 数组。

二分枚举答案 $\tt A$ ，于是问题就转化成 $\tt N$ 个串是否可以有度为 $\tt A$ 的公共字串，而代价是，我们多出来了一个 $\tt O(\log L)$ 的时间复杂度。

如果能找出 $h e i g h t$ 数组中连续的一段 $\tt [i,j]$ ，满足排完序的后缀中第 $\tt [i, j]$ 个后缀的起始字符分别属于 $\tt \{S_1,…,S_n\}$ 中的每个字符串，使得

$\tt \min_{k \in [i +1, j]}(height[k])>=A$

那么 $\tt A$ 就是可行解，否则不是。

具体查找 $\tt [i, j]$ 时，可以先从前到后枚举 $\tt i$ 的位置，如果发现 $\tt height_i>=A$ ，则开始从 $\tt i$ 向后枚举 $\tt j$ 的位置，直到找到了 $\tt height_{j+1}<A$ ，判断是否满足上述情况。

如果满足，则 $\tt A$ 为可行解，然后直接返回，否则令 $\tt i=j+1$ 继续向后枚举。

$\tt S$ 中每个字符被访问了 $\tt O(1)$ 次， $\tt S$ 的长度为 $\tt NL+N-1$ ，所以时间复杂度为 $\tt O(NL)$ 。

到这里，我们就可以理解为什么分隔符 $\tt P_1..P_{N-1}$ 必须是不同的 $\tt N-1$ 个不在字符集中的字符了，这样才能保证 $\tt S$ 的后缀的公共前缀不会跨出一个原有串的范围。（当然你也可以用其他方法来避免）

算法优化

基数排序优化

我们知道，因为 $\tt rank$ 数组里的数一定在 $\tt [1, n]$ 的范围内，所以我们可以使用基数排序来代替快速排序。

二元组基数排序，我们需要先把第二关键字放进桶中，然后从小到大枚举每个桶，把桶里的数按照放进去的顺序挨个取出来，

再把第一关键字放进去，同样取出来，然后得到的数组就是排好序的了。

所以这个排序算法复杂度是 $\tt O(n)$ 的，这样优化后的时间复杂度就是 $\tt O(n\log n)$ 了

代码

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
char str[100010];
int cnt[100010];
int rk[100010];
int y[100010];
int SA[100010];
int height[100010];
int n, m;
int get_SA()
{
	for(int i = 1; i <= n; i++)
	{
		rk[i] = str[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[i]]--] = i; 
	}
	for(int k = 1; k <= n; k <<= 1)
	{
		int num = 0;
		for(int i = n - k + 1; i <= n; i++)
		{
			y[++num] = i;
		}
		for(int i = 1; i <= n; i++)
		{
			if(SA[i] > k)
			{
				y[++num] = SA[i] - k;
			}
		}
		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[y[i]]]--] = y[i];
			y[i] = 0;
		}
		swap(rk, y);
		rk[SA[1]] = 1;
		num = 1;
		for(int i = 2; i <= n; i++)
		{
			if(y[SA[i]] == y[SA[i - 1]] && y[SA[i] + k] == y[SA[i - 1] + k])
			{
				rk[SA[i]] = num;
			}
			else
			{
				rk[SA[i]] = ++num;
			}
		}
		if (num == n)
		{
			break;
		}
		m = num;
	}
	for(int i = 1; i <= n; i++)
	{
		printf("%d ", rk[i]);
	}
	printf("\n");
}

void get_height()
{
	for(int i = 1; i <= n; i++)
	{
		rk[SA[i]] = i;
	}
	int k = 0;
	for(int i = 1; i <= n; i++)
	{
		if(k)
		{
			k--;
		}
		int j = SA[rk[i] - 1];
		while(str[i + k] == str[j + k])
		{
			k++;
		}
		height[rk[i]] = k;
	}
	for(int i = 1; i <= n; i++)
	{
		printf("%d ", height[i]);
	}
	printf("\n");
}

int main()
{
	scanf("%s", str + 1);
	n = strlen(str + 1);
	m = 256;
	get_SA();
	get_height();
	return 0;
}

Evan_song1234

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
字符串处理-SA数组

后缀数组 SA\tt SASA 可以用于各方面字符串问题，其目的是求出这个字符串的所有后缀的按照字典序的排名。前置知识倍增 / DC3算法用途可以用来求最长公共子串，最长回文串等算法复杂度字符串长度为 n\tt nn时间O(nlog⁡n)\tt O(n\log n)O(nlogn)空间O(n)\tt O(n)O(n)算法实现要知道，最暴力算法就是把所有后缀找出来，然后用 sort\tt sortsort 排序虽然时间复杂度和这个算法一样 O(nlog⁡n)\tt O(n\log n
复制链接

扫一扫