【知识总结】后缀数组（Suffix_Array）

又是一个学了n遍还没学会的算法……

后缀数组是一种常用的处理字符串问题的数据结构，主要由 \(\mathrm{sa}\) 和 \(\mathrm{rank}\) 两个数组组成。以下给出一些定义：

\(\mathrm{str}\) 表示处理的字符串，长度为 \(\mathrm{len}\) 。（下标从\(0\)开始）

\([i,j)\)表示 \(\mathrm{str}\) 从\(i\)到\(j - 1\)的字串。

后缀\(i\)表示子串\([i,len)\)，以字典序排序。

\(sa[i]\)表示排名为\(i\)的后缀的起始位置（即后缀\(sa[i]\)是第\(i\)名）

\(rank[i]\)表示后缀\(i\)的排名（从\(0\)开始）。显然\(rank[sa[i]]=i\)。

一、基数排序

先简单介绍一下后缀数组的前置技能：基数排序。

以对整数数组 \(\mathrm{arr}\) 排序为例。从低到高遍历每一个十进制位，对于每个位：

\(1.\) \(\mathrm{arr}\) 数组已经按照前\(i-1\)位排好序，（\(i=0\)时忽略这句），现在我们将把它变为按前\(i\)位排好序。脑补以下整数的比较方式，现在应该把第\(i\)位作为第一关键字，前\(i-1\)位作为第二关键字。

\(2.\)统计第\(i\)位为数字\(a\)的数的数量，存入\(count[a]\)。

\(3.\)对 \(\mathrm{count}\) 数组求前缀和，算出最后一个第\(i\)位为\(a\)的数在按照前\(i\)位排序后数组中的位置的下一个。这句表达比较鬼畜，看下面的例子。

比如，\(i\)位为\(0\)的有\(2\)个，为\(1\)的有\(1\)个，为\(2\)的有\(3\)个，第\(3\)步以后 \(\mathrm{count}\) 位\(\{2,3,6\}\)，那么排序后\(arr[0]\)和\(arr[1]\)的第\(i\)位为\(0\)，\(arr[2]\)的第\(i\)位为\(1\)，\(arr[3]\)到\(arr[5]\)的第\(i\)位为\(2\)。

\(4.\)逆序遍历 \(\mathrm{arr}\) ，按照上一步中算出的第\(i\)位为\(a\)的数排序后的位置逆序填充临时数组。两个均逆序保证了对于第\(i\)位相同的数按照最初在 \(\mathrm{arr}\) 中的位置排序。

\(5.\)最后，把临时数组复制给 \(\mathrm{arr}\) ，此时 \(\mathrm{arr}\) 按照前\(i\)位有序。

int count[10];
for(int i = 1; i <= 10; i++, ra *= 10)
{
	memset(count, 0, sizeof(count));
	for (int j = 1; j <= n; j++)
		++count[arr[j] / ra % 10];//step 2
	for (int j = 1; j < 10; j++)
		count[j] += count[j - 1];//step 3
	for(int j = n - 1; j >= 0; j--)
		buc[--count[arr[j] / ra % 10]] = arr[j];
	memcpy(arr, buc, sizeof(int[n]));
}

二、倍增构造后缀数组

考虑我们现在有了对所有形如\([i,min(i+tmp,len))\)的子串排序的数组 \(\mathrm{sa}\) 和 \(\mathrm{rank}\) （对于相同的子串，它们的 \(\mathrm{rank}\) 值相同，在 \(\mathrm{sa}\) 中顺序任意），我们现在要构造对所有形如\([i,min(i+2tmp,len))\)的子串排序。最坏情况下，当\(2tmp\geq len\)时就得到了答案。

可以发现此时很类似于基数排序时排到某一位时的情况。此时，第一关键字是\([i,i+tmp)\)，第二关键字是\([i+tmp, i+2tmp)\)。并且，现在已经按照第二关键字排好序了。

于是我们先看看此处的基数排序。其中 \(\mathrm{kind}\) 是 \(\mathrm{rank}\) 中不同值的种数（由于 \(\mathrm{rank}\) 从\(0\)开始，也可以看成 \(\mathrm{rank}\) 中最大值加\(1\)），\(tp[i]\)表示哪个串的第二关键字在所有第二关键字中的排名是\(i\)。

void radix_sort()
{
	static int count[N];
	memset(count, 0, sizeof(int[kind]);
	for (int i = 0; i < len; i++)
		count[rank[tp[i]]]++;
	for (int i = 1; i < kind; i++)
		count[i] += count[i - 1];
	for (int i = len - 1; i >= 0; i--)
		sa[--count[rank[tp[i]]]] = tp[i];
}

然后我们来构造 \(\mathrm{tp}\) 数组。首先，对于起点在\([len-tmp,len)\)中的串，它们的第二关键字都是空串，排名是最低的。所以它们应当在 \(\mathrm{tp}\) 的开头：

for (int i = len - tmp; i < len; i++)
	tp[cnt++] = i;

然后，按照 \(\mathrm{sa}\) 加入剩下的串。注意只有起点在\(tmp\)及以后的串才能作为第二关键字。

for(int i=0;i<len;i++)
	if(sa[i]>=tmp)
		tp[cnt++]=sa[i]-tmp;

至此， \(\mathrm{tp}\) 数组构造完毕，可以进行基数排序。排序后，我们要按照新的 \(\mathrm{sa}\) 和旧的 \(\mathrm{rank}\) 构造新的 \(\mathrm{rank}\) 。首先，把旧的 \(\mathrm{rank}\) 进行拷贝：

memcpy(tp, rank, sizeof(int[n]));

记住，此后 \(\mathrm{tp}\) 就只是旧的 \(\mathrm{rank}\) 的一份拷贝了，没有更多实际意义。更新 \(\mathrm{rank}\) 的过程比较显然。

rank[sa[0]] = 0;
kind = 1;
for (int i = 1; i < len; i++)
{
	if (tp[sa[i]] == tp[sa[i - 1]] &&
		(sa[i] + tmp < len && sa[i - 1] + tmp < len) &&
		(tp[sa[i] + tmp] == tp[sa[i - 1] + tmp]))
		rank[sa[i]] = rank[sa[i - 1]];
	else
		rank[sa[i]] = kind++;
}

最后，如果\(kind=len\)，即 \(\mathrm{rank}\) 已经两两不同，则说明已经得出了答案。

三、应用：构造 \(\mathrm{height}\) 数组

我不会，你开心不qwq

更新时间：2019年12月7日，距离这篇博客最初发表（2018年12月13日）已经过去了将近一年。（在此期间我的博客写作风格发生了一些变化）

博主肯定不是学了一年才学会了求 height ，只是又懒又咕……

\(\mathrm{height}\) 太长了，以下暂且缩写为 \(h\) 。

首先是定义：\(h_i\) 表示 \(\mathrm{sa}_i\) 和 \(\mathrm{sa}_{i-1}\) 的最长公共前缀（LCP）。注意这是两个 字典序排名 连续的后缀，而不是两个 位置 （这里的「位置」指的是在原字符串中的位置，下同）连续的后缀。

定理：\(h_{\mathrm{rank}_i}+1\geq h_{\mathrm{rank}_{i-1}}\)

翻译成人话就是：对于一个位置 \(i\) ，从 \(i\) 开始的后缀与排名在它前一位的后缀的 LCP （即 \(h_{\mathrm{rank}_i}\) ），一定不小于从 \(i-1\) 开始的后缀与排名在它前一位的后缀的 LCP （即 \(h_{\mathrm{rank}_{i-1}}\) ）减去 \(1\) 。

为什么呢？如果 \(h_{\mathrm{rank}_{i-1}}=0\) 显然成立，所以我们只讨论 \(h_{\mathrm{rank}_{i-1}}>0\) 的情况。设 \(j\) 是排名在 \(i-1\) 前面的那个后缀（即 \(j=\mathrm{sa}_{\mathrm{rank}_{i-1}-1}\) ），那么根据定义，有 \([j,j+h_{\mathrm{rank}_{i-1}})=[i-1,i-1+h_{\mathrm{rank}_{i-1}})\) 。那么就有 \([j+1,j+h_{\mathrm{rank}_{i-1}})=[i,i-1+h_{\mathrm{rank}_{i-1}})\) 。也就是说 \(i\) 和 \(j+1\) 有长为 \(h_{\mathrm{rank}_{i-1}}-1\) 的 LCP。并且，由于 \(j\) 的字典序比 \(i-1\) 小，而它们的首字母是相同的，所以 \(j+1\) 的字典序一定比 \(i\) 小。因此，\(i\) 与它排名前一位的那个后缀的 LCP 一定不小于 \(h_{\mathrm{rank}_{i-1}}-1\) 。

具体实现：

for (int i = 0; i < n; i++)
{
	if (rank[i] == 0)
		continue;
	int j = sa[rank[i] - 1], k = height[rank[i - 1]];
	if (k)
		--k;
	while (i + k < n && j + k < n && str[i + k] == str[j + k])
		++k;
	height[rank[i]] = k;
}

\(k\) （也就是 \(h_{\mathrm{rank}_{i-1}}\)）不可能加到超过 \(n\) ，而 \(k\) 最多也只会减 \(n\) 次，因此时间复杂度是 \(O(n)\) 。

四、完整代码

namespace Suffix_Array
{
	int height[N], sa[N], rank[N], tp[N], kind, n;
	void radix_sort()
	{
		static int count[N];
		memset(count, 0, sizeof(int[kind]));
		for (int i = 0; i < n; i++)
			++count[rank[i]];
		for (int i = 1; i < kind; i++)
			count[i] += count[i - 1];
		for (int i = n - 1; i >= 0; i--)
			sa[--count[rank[tp[i]]]] = tp[i];
	}
	void build(const char *const s)
	{
		n = strlen(s);
		kind = CH;
		for (int i = 0; i < n; i++)
			tp[i] = i, rank[i] = ctoi(s[i]);
		radix_sort();
		for (int len = 1; len < n; len <<= 1)
		{
			int cnt = 0;
			for (int i = n - len; i < n; i++)
				tp[cnt++] = i;
			for (int i = 0; i < n; i++)
				if (sa[i] >= len)
					tp[cnt++] = sa[i] - len;
			radix_sort();
			memcpy(tp, rank, sizeof(int[n]));
			kind = 0;
			rank[sa[0]] = kind++;
			for (int i = 1; i < n; i++)
			{
				if (tp[sa[i]] == tp[sa[i - 1]] &&
						sa[i] + len < n && sa[i - 1] + len < n &&
						tp[sa[i] + len] == tp[sa[i - 1] + len])
					rank[sa[i]] = kind - 1;
				else
					rank[sa[i]] = kind++;
			}
			if (kind == n)
				break;
		}
		for (int i = 0; i < n; i++)
		{
			if (rank[i] == 0)
				continue;
			int j = sa[rank[i] - 1], k = height[rank[i - 1]];
			if (k)
				--k;
			while (i + k < n && j + k < n && str[i + k] == str[j + k])
				++k;
			height[rank[i]] = k;
		}
	}
}