后缀数组

参考:https://www.bilibili.com/video/av92589768?from=search&seid=11036159274843024348

符号

子串

从原串中选取连续的一段即为子串，空串也是子串

后缀

我们用$suf(k)$表示$s(k\dots n)$构成的子串

任何子串都是某个后缀的前缀

最长公共前缀lcp

$lcp(suf(i),suf(j))$ 表示两个串$suf(i)$和$suf(j)$最长的一样的前缀

问题

将所有后缀$suf(1),suf(2),\dots ，suf(N)$按照字典序从小到大排序

方法1

首先看到题目想到的就是直接用暴力，建一个$cmp$数组，用$string$可以比较大小的性质去暴力$sort$

因为$sort$是$n\log n$的，每次$cmp$函数都是$O(n)$的，所以总的时间复杂度就是 $n^2\log n$

方法2

想一想更好的做法，我们可以用二分+hash

复杂度：$n{\log }^{2}n$

$cmp$函数中二分$suf(i)$和$suf(j)$的$lcp$

$returns[i+|lcp|]<s[j+|lcp|]$

方法3

$SA$算法

$SA[l] = $ 排名第$l$的后缀的开始位置

$Rank[i] = $ 后缀$suf(i)$的排名

Rank[SA[l]] = l;
SA[Rank[i]] = i;

求出其中一个就能$O(n)$求出另一个

有什么求其中一个数组的好的方法呢？

答案是倍增

方法三实现优化

倍增

记$sub[i][k]=s$从$i$开始长度$=s^k$的子串

$sub[i][k]=s[i\dots i+(1<<k)-1]$，超过$n$的部分都视为**’\0’**（字典序最小的字符）

$rank[i][k]=sub[i][k]$在长度$=2^k$的所有子串中的排名

$sa[l][k] = $在长度$=2^k$的所有子串中排名第$l$的子串的开始位置

过程

1. 求出$sub[1][0],sub[2][0],\dots ，sub[n][0]$的字典排序
2. 求出$sub[1][1],sub[2][1],\dots ，sub[n][1]$的字典排序
3. ……
4. 求出$sub[1][k],sub[2][k],\dots ，sub[n][k]$的字典排序

当子串长度$2^k>=n$时，子串排序就是后缀排序

利用$rank[1\dots n][k]$,如何求出$rank[1\dots n][k+1]$

对于两个子串$sub[i][k+1]$和$sub[j][k+1]$

先比较$rank[i][k]<rank[j][k]$

若相等，再比较$rank[i+2^k][k]<rank[j+2^k][k]$

其实就相当于对二元组$(rank[i][k],rank[i+2^k][k])$排序

$pair$排序时，先按$first$比较，若相等再按$second$比较

但如果建$pair$数组直接$sort$的话，复杂度还是$n{\log }^{2}n$，还不如写二分+hash

于是这个时候就出现了一个神奇的东西：基数排序

为什么可以优化呢？我们注意到$rank$这个数组，他的值域是多少？

没错，值域就是不超过$n$的正整数，所以我们就可以用基数排序，换句话说就是桶排序

关于基数排序的相关，看可以去看一下洛谷日报第十五期，这里给出链接：基数排序

写$SA$时的基数排序用$cnt$实现

如何将$a[i]$数组基数排序，然后将结果放在$SA$数组中呢？

下面的代码就实现了输入一个$a$数组，得到$sa$数组

for (int i = 1; i <= n; i++) ++cnt[a[i]];
for (int i = 1; i <= n; i++) cnt[i] += cnt[i - 1];
for (int i = n; i >= 1; i--) sa[cnt[a[i]]--] = i;

比如一个$a$数组为

$a=[2,1,2,4,2]$

若用$sa[l]$表示排名第$l$的数在$a$中的下标

则$sa=[2,1,3,5,4]$

就可以根据

Rank[SA[l]] = l;
SA[Rank[i]] = i;

得出$rank$数组

$rank=[2,1,2,3,2]$

到这里我们就能回到一开始的问题，实现用$rank[1\dots n][k]$,如何求出$rank[1\dots n][k+1]$，步骤如下:

$for(k=1\sim \log n)$

• 按$rank[i+2^k][k]$（第二关键字）基数排序
• 按$rank[i][k]$（第一关键字）基数排序，得到$sa[i][k+1]$数组
• 由$sa[i][k+1]$求出$rank[i][k+1]$

如果你细心的话可能会发现，$k$是从$1$开始的而不是从$0$开始的，那么$k$是$0$时候怎么来的呢？

因为$2^0$就是$1$，所以我们可以直接把$rank$数组（也就是排名）先设成当前字符的$\text{ASCII}$码，这样就可以啦~

sa->rank

如果$rk[i]$中有并列

for (int p = 0, i = 1; i <= n; i++) {
	if(oldrk[sa[i]] == oldrk[sa[i - 1]] && oldrk[sa[i] + k] == oldrk[sa[i - 1] + k])
		rk[sa[i]] = p;
	else rk[sa[i]] = ++p;
}

代码

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

const int A = 1e6 + 11;

inline int read() {
	char c = getchar();
	int x = 0, f = 1;
	for ( ; !isdigit(c); c = getchar()) if (c == '-') f = -1;
	for ( ; isdigit(c); c = getchar()) x = x * 10 + (c ^ 48);
	return x * f;
}

char s[A];
int n, m, sa[A], rank[A], tp[A], tax[A];

void cntsort() {
	for (int i = 0; i <= m; i++) tax[i] = 0;
	for (int i = 1; i <= n; i++) tax[rank[i]]++;
	for (int i = 1; i <= m; i++) tax[i] += tax[i - 1];
	for (int i = n; i >= 1; i--) sa[tax[rank[tp[i]]]--] = tp[i];
}

void Sort() {
	m = 75;
	for (int i = 1; i <= n; i++) rank[i] = s[i] - '0' + 1, tp[i] = i;
	cntsort();
	for (int w = 1, p = 0; p < n; m = p, w <<= 1) {
		p = 0;
		for (int i = 1; i <= w; i++) tp[++p] = n - w + i;
		for (int i = 1; i <= n; i++) if(sa[i] > w) tp[++p] = sa[i] - w;
		cntsort();
		swap(tp, rank);
		rank[sa[1]] = p = 1;
		for (int i = 2; i <= n; i++) {
			rank[sa[i]] = (tp[sa[i - 1]] == tp[sa[i]] && tp[sa[i - 1] + w] == tp[sa[i] + w]) ? p : ++p;
		}
	}
}

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

Height数组

我们通过求$SA$数组可以把所有后缀排序，那么排序之后有啥用呢？？

其实是为了快速的求出任意两个后缀的$lcp$长度

我们记$Height[l] = $排名第$l-1$的后缀和排名第$l$的后缀的$lcp$长度

$Height[l]=lcp(suf(SA[l-1],suf(SA[l])))$

$Height[1]$可以视作$0$。

假设$l=$后缀$suf(i)$的排名，$r = $后缀$suf(j)$的排名（在此$l$不一定小于$r$，只是举例）

那么有结论：

• $lcp(suf(i),duf(j))=min(Height[l+1]\dots Height[r])$
• 即两个后缀的$lcp=$它们排名区间中$Height$的最小值

可以用数据结构维护$rmp$

为什么可以这么理解呢？

假设有三个字符串$s_1,s_2,s_3$，且$s_1<s_2<s_3$（按$rank$排名得出）

那么$lcp(s_1,s_3)$就等于$min(lcp(s_1,s_2),lcp(s_2,s_3))$

(详细证明需要画图……我真的懒)

$lcp(s_1,s_3)>=min(lcp(s_1,s_2),lcp(s_2,s_3))=1$

又有$s_1[l+1]!=s_3[l+1]$

求法

那么如何快速求出$Height$数组呢？

纯暴力$O(n^2)$

for i = 1 - N
	l = rank[i]
	j = sa[l - 1]
	k = 0
	while (s[i + k] ==s [j + k]): ++k
	Height[l] = k

令$l=rank[i],r=rank[i-1]$
$Height[l]=lcp(suf(SA[l-1]),suf(i))$
$Height[r]=1cp(suf(SA[r-1])，suf(i-1))$

有重要结论:
$Height[l]>=Height[r]-1$

• 若$Height[r]>1$,有$suf(SA[r-1])<suf(SA[i-1])$
• 去掉首个字符 $lcp(suf(SA[r-1]+1)，suf(SA[i]))=Height[r]-1$
• $suf(SA[r-1]+1)<suf(SA[i])$
• 由于$Height[1] $是$suf(i)$与排名紧挨着自己的后缀的$lcp$,有
• $suf(SA[r-1]+1)<=suf(SA[1-1])<suf(SA[i])$

相近的$Height$会比较相似，比较远的会差别很大

不恰当的例子：

优化$O(n)$

利用$Height[rank[i]]>=Height[rank[i-1]]-1$
优化暴力即可，复杂度$0(N)$

for i = 1 - N
	j = sa[l - 1]
	k = max(0, Height[rank[i - 1]] - 1)
	while (s[i + k] == S[j+k]): ++k
	Height[rank[i]] = k

之后再用$st$表之类的维护$Height$的$rmq$信息即可