【ACWing】2715. 后缀数组

题目地址：

https://www.acwing.com/problem/content/2717/

给定一个长度为$n$的字符串，只包含大小写英文字母和数字。将字符串中的$n$个字符的位置编号按顺序设为$1\sim n$。并将该字符串的$n$个非空后缀用其起始字符在字符串中的位置编号表示。现在要对这$n$个非空后缀进行字典序排序，并给定两个数组$sa$和$height$。排序完成后，用$sa[i]$来记录排名为$i$的非空后缀的编号，用$height[i]$来记录排名为$i$的非空后缀与排名为$i-1$的非空后缀的最长公共前缀的长度（$1\le i\le n$）。特别的，规定$height[1]=0$。请你求出这两个数组。

输入格式：
共一行，包含一个长度为$n$的仅包含大小写英文字母或数字的字符串。

输出格式：
第一行包含$n$个整数，表示$sa$数组。
第二行包含$n$个整数，表示$height$数组。

数据范围：
$1\le n\le 10^6$

后缀数组的构造一般用倍增法来做。假设字符串下标从$1$开始计数，设$s[i][2^k]=s[i:i+2^k-1]$（如果越界了则用空字符补齐，规定空字符的字典序最小），那么对于$s[i][2^0]$的排序可以直接按单个字母的字典序顺序来排；假设$\forall i,s[i][2^k]$已经排好，考虑对$\forall i,s[i][2^{k+1}]$来排序，而其可以视为二元组$(s[i][2^k],s[i+2^k][2^k])$，从而对其的排序可以视为是对二元组的排序，而对二元组的排序可以用$s[i][2^k]$的排序的结论来排。当$2^k\ge n$的时候，也就排好了序。每一轮排序的时候，可以用基数排序做到$O(n)$，而一共倍增$\log n$次，所以总时间复杂度就是$O(n\log n)$。用基数排序的时候，需要对长$2^k$的子串做离散化，可以直接用排名来离散化。

接下来考虑高度数组怎么求。设$lcp(i,j)$表示排名第$i$的后缀和排名第$j$的后缀的最长公共前缀的长度，那么显然$lcp(i,j)=lcp(j,i)$。设$i<k<j$，我们有： l c p ( i , j ) = min ⁡ { l c p ( i , k ) , l c p ( k , j ) } lcp(i, j)=\min\{lcp(i, k),lcp(k, j)\} lcp(i,j)=min{lcp(i,k),lcp(k,j)}考虑高度数组$height$，设$h[i]=height[rk[i]]$，即$h[i]$表示第$i$个后缀和比其字典序小$1$的后缀的最长公共前缀长度，则有$$h[i]\ge h[i-1]-1$$可以这样想，如果$h[i-1]=0$的话显然成立；否则设排名第$rk[i-1]-1$的后缀是$s[k:]$，那么$s[i:]$和$s[k+1:]$的最长公共前缀就是$s[i-1:]$和$s[k:]$的最长公共前缀减去$1$，即$h[i-1]-1$，而由$lcp$的性质，排名范围跨度大的最长公共前缀长度不大于排名范围跨度小的最长公共前缀长度，所以有$h[i]\ge h[i-1]-1$。

有了关于$height[rk[i]]$的表达式之后，就可以快速求出高度数组了，可以在$O(n)$时间内求出（因为在求完$k=height[rk[i]]$之后，可以直接从$k-1$开始枚举长度，求出$height[rk[i+1]]$）。

代码如下：

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

const int N = 1e6 + 10;
// m是离散化的最大值
int n, m;
char s[N];
// sa[i]排名第i位的是第几个后缀
// rk[i]第i个后缀排名是多少，在排序的过程中，rk是每个后缀用第一关键字的排名来离散化之后的值
// he[i]是sa[i]与sa[i - 1]的最长公共前缀的长度
// y[i]是按第二关键字排的情况下第i个后缀的排名
int sa[N], rk[N], y[N], c[N], he[N];

void get_sa() {
  // 将所有后缀按第一个字母排序，排序结果存入sa
  // 先将每个后缀离散化为其第一个字母的ASCII码值
  for (int i = 1; i <= n; i++) c[rk[i] = s[i]]++;
  for (int i = 2; i <= m; i++) c[i] += c[i - 1];
  for (int i = n; i; i--) sa[c[rk[i]]--] = i;

  // 每一轮按长2k的前缀来对所有后缀排序
  for (int k = 1;; k <<= 1) {
    // 先按第二关键字排序
    int num = 0;
    // 长度不够k的那些后缀第二关键字为空，最小，先排它们
    for (int i = n - k + 1; i <= n; i++) y[++num] = i;
    // 按以长k前缀的字典序从小到大遍历所有后缀，只看第k + 1个及其以后的后缀，只有它们可以作为第二关键字
    for (int i = 1; i <= n; i++)
      if (sa[i] > k)
        // 第sa[i]个后缀是第sa[i] - k个后缀的第二关键字
        y[++num] = sa[i] - k;
    // 到此，y存的是所有后缀按第二关键字排好序的结果，即y[i]是排名第i的后缀是第几个后缀
    // 接下来要将所有后缀按第一关键字排序
    for (int i = 1; i <= m; i++) c[i] = 0;
    for (int i = 1; i <= n; i++) c[rk[i]]++;
    for (int i = 2; i <= m; i++) c[i] += c[i - 1];
    // rk[y[i]]是排名第i的后缀的第一关键字离散化之后的值
    for (int i = n; i; i--) sa[c[rk[y[i]]]--] = y[i];
    // 到此sa已经是两个关键字都排好序的结果
    // 接下来y没用了，将rk覆盖掉y，并且重新做离散化，此时是将每个后缀按照长2k的前缀来离散化
    swap(rk, y);
    rk[sa[1]] = num = 1;
    for (int i = 2; i <= n; i++)
      rk[sa[i]] = y[sa[i]] == y[sa[i - 1]] && y[sa[i] + k] == y[sa[i - 1] + k] ? num : ++num;
    // 如果离散化后两两不同，说明本轮排好序后，已经没有排名一样的后缀了，说明已经整体排好序，直接退出
    if (num == n) break;
    // 更新离散化的最大值
    m = num;
  }
}

void get_height() {
  // 按排名枚举后缀
  for (int i = 1, k = 0; i <= n; i++) {
  	// 如果排名第1，那高度为0，略过
    if (rk[i] == 1) continue;
    // 找到排名少1位的后缀是第几个
    int j = sa[rk[i] - 1];
	if (k) k--;
	// 直接暴力枚举
    while (i + k <= n && j + k <= n && s[i + k] == s[j + k]) k++;
    he[rk[i]] = k;
  }
}

int main() {
  scanf("%s", s + 1);
  
  n = strlen(s + 1), m = 'z';
  get_sa();
  get_height();

  for (int i = 1; i <= n; i++) printf("%d ", sa[i]);
  puts("");
  for (int i = 1; i <= n; i++) printf("%d ", he[i]);
  puts("");

  return 0;
}

时间复杂度$O(n\log n)$，空间$O(n)$。