字符串基础

标签：子串 后缀 基础 ht 字符串 sa rk 回文

几乎所有字符串算法都存在一个共性：基于所求信息的特殊性质与已经求出的信息，使用增量法与势能分析求得所有信息。这体现了动态规划思想。

Manacher 很好地证明了这一点：它维护所求得的最右回文子串的回文中心 \(d\) 与回文半径 \(r\)，利用回文性质通过均摊右端点移动距离在线性时间内求出以每个位置为中心的最长回文半径。

SA，KMP，Z 与 SAM 等常见字符串算法无不遵循这一规律。读者在阅读时注意体会这种思想，笔者认为其对于提升解决问题的能力有很大帮助。

定义与记号

约定：

• 文章使用打字机字体 texttt 描述一个字符串的具体内容，例如 \(s = \texttt {alexwei}\)。
• 无歧义时，\(n\) 表示当前描述的字符串的长度。在字符串两侧加上 \(|\) 表示长度。
• 当下标 \(i\) 不在 \([1, n]\) 范围内时，对应位置的字符 \(s_i\) 视为空字符。

基本定义：

• 字符集：字符集 可以是任何具有全序关系的集合 \(\Sigma\)，即 \(\Sigma\) 中任意两个不同元素 \(x, y \in \Sigma\)（\(x\neq y\)）可比较大小。除非特殊规定，一般按字母表顺序或数码大小比较元素。
• 字符：字符集 \(\Sigma\) 中的元素称为 字符。\(s_i\) 或 \(s[i]\) 表示 \(s\) 的第 \(i\) 个字符。
• 空串：不含任何字符的字符串称为 空串，记作 \(\epsilon\)，\(|\epsilon| = 0\)。空串之于字符串类似空集之于集合。
• 子串：由 \(s\) 在开头或末尾删去若干字符得到的字符串称为 \(s\) 的 子串。\(s\) 本身和空串均为 \(s\) 的子串。\(s[l, r]\) 或 \(s_{l, r}\) 表示 \(s\) 位置 \(l\sim r\) 上的字符连接而成的子串，当 \(l > r\) 时为空串。
• 反串：翻转 \(s\) 得到 \(s\) 的 反串，记作 \(s ^ R\)。
• 回文串：\(s = s ^ R\) 的串称为 回文串。特别地，空串是回文串。
• 拼接：\(s + t\) 表示将 \(t\) 拼接在 \(s\) 后。

前后缀相关：

• 前缀：在 \(s\) 末尾删去若干字符得到的字符串称为 \(s\) 的 前缀，形如 \(s[1, i]\)（\(0\leq i \leq n\)），记作 \(pre_i\)。\(s\) 本身和空串均为 \(s\) 的前缀。
• 后缀：在 \(s\) 开头删去若干字符得到的字符串称为 \(s\) 的 后缀，形如 \(s[i, n]\)（\(1\leq i \leq n + 1\)），记作 \(suf_i\)。\(s\) 本身和空串均为 \(s\) 的后缀。
• 真前 / 后缀：真前缀 表示非原串前缀，真后缀 同理。
• 最长公共前缀：\(\mathrm{lcp}(s, t)\) 表示 \(s\) 和 \(t\) 的 最长公共前缀（Longest Common Prefix），即最长的 \(u\) 使得 \(u\) 同时为 \(s\) 和 \(t\) 的前缀。最长公共后缀（Longest Common Suffix）同理。
• 字典序：定义空字符小于任何字符。称 \(s\) 的 字典序 小于 \(t\) 当且仅当去掉 \(\mathrm{lcp}(s, t)\) 后，\(s\) 的第一个字符小于 \(t\) 的第一个字符。等价于以第 \(i\) 个字符作为第 \(i\) 关键字比较。

匹配相关：

• 出现位置：若 \(s[p - |t| + 1, p] = t\)，则称 \(t\) 在 \(s\) 中以位置 \(p\) 出现。\(t\) 在 \(s\) 中的 出现位置 等于 \(t\) 的最后一个字符在 \(s\) 中的对应位置。例如，若 \(s = \texttt{abcbabc}\)，\(t = \texttt{abc}\)，则 \(t\) 在 \(s\) 中的所有出现位置为 \(\{3, 7\}\)。

• 匹配：称字 \(t\) 匹配 \(s\) 当且仅当 \(t\) 在 \(s\) 中出现。

• 模式串（单词）：用于匹配的字符串称为 模式串，相当于题目给定的 单词。

• 字典：题目给定的所有模式串的集合称为 字典。

• 文本串：被匹配的字符串称为 文本串。

• 分清模式串和文本串的定义：用 \(t\) 匹配 \(s\) 即求 \(t\) 在 \(s\) 中的所有出现位置，\(t\) 是 用于匹配的串，称为模式串（模式串是我们要寻找的模式，是子串）；\(s\) 是 被匹配的串，称为文本串（文本串相当于给出的文本，是主串）。

1. Manacher 算法

Manacher 在所有字符串算法中理解起来相对容易，学习它有助于理解 Z 算法。

Manacher 在 NOI 大纲里是 8 级算法。

1.1 相关定义

根据回文串的定义，我们发现奇回文串和偶回文串本质不同。当 \(n\) 为奇数时，其 回文中心 为它最中间的位置 \(\frac {n + 1} 2\)；当 \(n\) 为偶数时，其回文中心为位置 \(mid\) 与 \(mid + 1\) 之间的空隙，其中 \(mid = \frac n 2\)。

此外，定义回文串 \(s\) 的 回文半径 为其开头到回文中心形成的字符串长度。当 \(|s|\) 是奇数时，\(s\) 的回文半径为 \(\frac {n + 1} 2\)；当 \(n\) 是偶数时，\(s\) 的回文半径为 \(\frac n 2\)。

容易发现对于 \(s\) 的某个回文子串 \(s[l, r]\)，若 \(l < r\)，则 \(s[l + 1, r - 1]\) 回文。因此，若 \(x\) 是 \(i\) 的回文半径，则任何小于等于 \(x\) 的正整数均为 \(i\) 的回文半径。因此，考虑一个回文中心：

• 当它是下标 \(i\) 时，存在阈值 \(R\) 满足当 \(0\leq j < R\) 时 \(s[i - j, i + j]\) 回文，\(R\) 称为以位置 \(i\) 为回文中心的 最长回文半径 \(R_i\)。它可以理解为以 \(i\) 为回文中心的回文子串数。
• 同理，当它是 \(i\) 与 \(i + 1\) 之间的空隙时，存在阈值 \(R\) 满足当 \(0\leq j < R\) 时，\(s[i - j, i + 1 + j]\) 回文。

1.2 统一奇偶回文子串

为避免分类讨论，我们尝试将所有偶回文子串转化为奇回文子串。

容易发现，若将所有空隙视作一种独立的 分隔字符，则偶回文子串可视为以对应分隔符为回文中心的奇回文子串。例如 \(\texttt {abbbba}\)，若将空隙视为字符 \(\texttt c\)，则原串变为新串 \(\texttt {cacbcbcbcbcac}\)。

考虑原串偶回文子串在新串上的形态。偶回文子串 \(\texttt {bb}\) 对应新串 \(\texttt {cbcbc}\)，\(\texttt {abbbba}\) 对应新串 \(\texttt {cacbcbcbcbcac}\)。手动模拟可知若某分隔符在新串上的最长回文半径为 \(R_i\)（一定是奇数），则它对应的原串最长回文子串长度为 \(R_i - 1\)。

考虑原串奇回文子串在新串上的形态。奇回文子串 \(\texttt{bbb}\) 对应新串 \(\texttt {cbcbcbc}\)。手动模拟可知若某原串下标在新串上的最长回文半径为 \(R_i\)（一定是偶数），则它对应的原串最长回文半径为 \(\frac {R_i} 2\)，最长回文子串长度同样为 \(R_i - 1\)。

这样，我们统一了奇回文串和偶回文串从新串转回原串的过程，有效减少了根据最长回文半径 \(R_i\) 求解问题的细节，并得到结论：新串的 \(R_i\) 表示原串以对应下标或空隙为中心的最长回文子串长度加 \(1\)。

1.3 算法介绍

Manacher 算法可以求出以每个位置 \(i\) 为回文中心的最长回文半径 \(R_i\)。当然，也可以求出以每个空隙为回文中心的最长回文半径。这种情况已经转化为前者。

首先将 \(s\) 的所有字符之间插入相同分隔符，包括头尾，然后在整个字符串头尾插入另外两种不同的分隔符，以防止越界。

朴素想法是对每个回文中心 \(i\)，从 \(1\) 开始从小到大暴力枚举 \(R_i\)。很遗憾，全 \(\texttt {a}\) 串就可以将复杂度卡成 \(\mathcal{O}(n ^ 2)\)。具体复杂度是 \(n\) 加上 \(s\) 的回文子串数量，出现在不同位置的相等子串 算多个。

只需加上一些优化即可将复杂度变为 \(\mathcal{O}(n)\)。

回顾朴素暴力，在从 \(R_i = 1\) 开始枚举的过程中，我们浪费了很多由回文性质带来的有用信息。考虑回文中心 \(c\) 及其右端点 \(r = c + R_c - 1\)，若当前希望求出 \(R_i\)（\(c < i\)） 且满足 \(i \leq r\)，则我们完全可以利用 \(2c - i\) 处已经求得的 \(R_{2c - i}\) 的信息。

具体地，在 \(c\) 的最长回文半径范围内，因为 \(c < i \leq r\)，所以 \(2c - i\) 和 \(i\) 在该范围内对称。也就是说，在 \([c - R_c + 1, c + R_c - 1]\) 范围内，以 \(2c - i\) 为对称中心的回文串也是以 \(i\) 为对称中心的回文串。因此，我们得出 \(R_i \geq \min(r - i + 1, R_{2c - i})\)。

如上图，因为黄色部分回文，所以对于以 \(2c - i\) 为回文中心且落在黄色部分的回文串（橙色部分），一定也在 \(i\) 处出现。

因此，考虑维护已经计算过的所有回文中心对应的最长回文子串的右端点的最大值 \(r = \max_{p = 1} ^ {i - 1} p + R_p - 1\) 以及对应回文中心 \(c\)。

对于当前位置 \(i\)，若 \(r < i\)，则从 \(0\) 开始枚举求得 \(R_i\)。此时每次扩展均使得 \(r\) 向右移动 \(1\)。

否则 \(i\leq r\)，利用回文性质和已经求出的信息，先将 \(R_i\) 赋值为 \(\min(r - i + 1, R_{2c - i})\)，再逐位扩展：

• 若 \(R_{2c - i} < r - i + 1\)，则 \(R_i\) 就等于 \(R_{2c - i}\)。否则根据对称性 \(R_{2c - i}\) 可以更大，与其最大性矛盾。
• 否则 \(R_i\) 被初始化为 \(r - i + 1\)，使得每次扩展都会将 \(r\) 向右移动 \(1\)。

综上，时间复杂度线性。

模板题 P3805 代码如下：

#include <bits/stdc++.h>
using namespace std;
const int N = 2.2e7 + 5;
int n, m, ans, R[N];
char s[N], t[N];
int main() {
  scanf("%s", s + 1), n = strlen(s + 1);
  t[0] = '!', t[m = 1] = '@';
  for(int i = 1; i <= n; i++) t[++m] = s[i], t[++m] = '@'; // 间隔插入字符.
  t[++m] = '#';
  for(int i = 1, c = 0, r = 0; i < m; i++) { // r 是最右回文边界, c 是对应回文中心.
    R[i] = r < i ? 1 : min(R[c * 2 - i], r - i + 1); // 若 i <= r, 则根据对称性继承信息.
    while(t[i - R[i]] == t[i + R[i]]) R[i]++;
    ans = max(ans, R[i] - 1);
    if(i + R[i] - 1 > r) c = i, r = i + R[i] - 1; // 更新 r 和 c.
  }
  cout << ans << endl;
  return 0;
}

1.4 结论与应用

Manacher 本身证明了一个关于回文子串的结论：一个字符串的本质不同回文子串个数不大于 \(n\)。因为所有以 \(i\) 为回文中心的长度小于等于 \(\min(r - i + 1, R_{2c - i})\) 的回文子串均与以 \(2c - i\) 为回文中心的对应长度的回文子串相等。故以 \(i\) 为回文中心，每找到一个在此之前没有出现过的回文子串，均会使 \(r\) 增加 \(2\)（找到回文子串后，因为分隔符回文再扩展一步）。注意，使 \(r\) 增加并不一定代表找到新的回文子串。

当然，我们也可以不借助 Manacher 直接证明这一结论。考虑在每个回文子串第一次出现处计入贡献。若存在两个本质不同回文子串 \(p, q\) 在同一右端点处贡献答案，不妨设 \(|p| < |q|\)，则根据回文性 \(q[1, |p|] = p\)，与 \(p\) 第一次出现在 \(q[|q| - |p| + 1, |q|]\) 处矛盾。因此一个右端点至多贡献一个本质不同回文子串。

利用 Manacher，我们可以求出以每个字符开头或结尾的最长回文子串：考虑位置 \(i\) 及其最长回文半径 \(R_i\)，若 \(i + R_i - 1 > r\)，根据算法，用 \(i + R_i - 1\) 更新 \(r\)。更新前枚举 \(j\in[r + 1, i + R_i - 1]\)，若 \(t_j\) 对应原串字符 \(s_k\) 而非分隔符，则原串中以 \(s_k\) 结尾的最长回文子串长度为 \(j - i + 1\)。通过分奇偶性讨论和模拟可证其正确性。代码实现见例题 P4555。

1.5 例题

UVA11475 Extend to Palindrome

找到最小的使得 \(s[l, r]\) 为回文串的 \(l\)，则答案即 \(s\) 加上 \(s[1, l - 1]\) 翻转后的结果。代码。

P3501 [POI2010] ANT-Antisymmetry

借鉴 Manacher 的思路，我们对每个位置求出最长 Anti-symmetry 半径。同样的，记录最右边的回文区间，快速继承和扩展做到均摊线性。代码。

P4555 [国家集训队] 最长双回文串

对每个位置求出以该字符结尾和开头的最长回文子串 \(lft_i\) 和 \(rt_i\)，则 \(\max_{i = 1} ^ {n - 1} lft_i + rt_{i + 1}\) 即为所求。

时间复杂度线性。

#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, m, ans, R[N], lft[N], rt[N];
char s[N], t[N];
int main() {
  scanf("%s", s + 1), n = strlen(s + 1);
  t[0] = '!', t[m = 1] = '@';
  for(int i = 1; i <= n; i++) t[++m] = s[i], t[++m] = '@';
  t[++m] = '#';
  for(int i = 1, c = 0, r = 0; i < m; i++) {
    R[i] = i > r ? 1 : min(R[2 * c - i], r - i + 1);
    while(t[i - R[i]] == t[i + R[i]]) R[i]++;
    if(i + R[i] - 1 > r) {
      for(int j = r + 1; j < i + R[i]; j++) if(j & 1 ^ 1) lft[j >> 1] = j - i + 1; // 新串的偶数位置对应一个原串字符.
      c = i, r = i + R[i] - 1;
    }
  }
  for(int i = m - 1, c = m, r = m; i; i--) { // 倒过来做一遍 Manacher.
    R[i] = i < r ? 1 : min(R[2 * c - i], i - r + 1);
    while(t[i - R[i]] == t[i + R[i]]) R[i]++;
    if(i - R[i] + 1 < r) {
      for(int j = i - R[i] + 1; j < r; j++) if(j & 1 ^ 1) rt[j >> 1] = i - j + 1;
      c = i, r = i - R[i] + 1;
    }
  }
  for(int i = 1; i < n; i++) ans = max(ans, lft[i] + rt[i + 1]);
  cout << ans << endl;
  return 0;
}

P1659 [国家集训队] 拉拉队排练

因为题目要求奇回文串，所以只考虑以下标 \(i\) 为回文中心。若新串位置 \(k\) 对应原串下标 \(i\)，则此时所有长度 \(j \in [1, \frac{R_k} 2]\) 的回文半径均存在，相当于对 \(1, 3, \cdots, R_k - 1\) 进行单点加，最后全局查询。差分维护即可。

时间复杂度是快速幂的 \(\mathcal{O}(n\log n)\)。代码。

P5446 [THUPC2018] 绿绿和串串

如果 \(pre_i\) 能生成 \(s\)，则以 \(i\) 为回文中心时，要么存在顶到结尾的回文串，要么存在顶到开头的回文串且 \(pre_{2i - 1}\) 能生成 \(s\)。

Manacher 求出每个位置的最长回文半径后倒过来 dp 一遍即可。

时间复杂度 \(\mathcal{O}(n)\)。代码。

2. Z 算法 / 扩展 KMP

扩展 KMP 在 NOI 大纲里是 9 级算法。它和 KMP 没有关系。

2.1 算法简介

定义字符串 \(s\) 的 Z 函数 \(z_i\) 表示 \(s\) 的 \(i\) 后缀与 \(s\) 本身的最长公共前缀长度，即 \(z_i = |\mathrm{lcp}(pre_i, s)|\)。\(z_1\) 无用，一般令 \(z_1 = n\)。

每次暴力匹配，时间复杂度 \(\mathcal{O}(n ^ 2)\)。它没有利用任何已经求出的 \(z_1, z_2, \cdots, z_{i - 1}\) 的信息，很不优美。

Z 算法利用已经求得的信息的性质，通过增量法求出 Z 函数。

称 \([i, i + z_i - 1]\) 为 \(i\) 的匹配段，也称 Z-box。据定义，\(s[i, i + z_i - 1] = s[1, z_i]\)。

类似 Manacher，实时维护最靠右侧的匹配段 \([l, r]\)。匹配到位置 \(i\) 时，分两种情况讨论：

• 若 \(i > r\)，直接暴力匹配。
• 若 \(i \leq r\)，因为 \(s[1, r - l + 1] =s [l, r]\)，所以 \(s[i, r] = s[i - l + 1, r - l + 1]\)。因此 \(suf_i\) 的 \(r - i + 1\) 前缀和 \(suf_{i - l + 1}\) 的 \(r - i + 1\) 前缀相等。故首先令 \(z_i \gets \min(r - i + 1, z_{i - l + 1})\)，然后暴力匹配。

读者可以发现 Z 算法和 Manacher 的核心思想几乎一模一样。

时间复杂度：当 \(z_{i - l + 1} < r - i + 1\) 时，\(z_i\) 不可能继续向下匹配，否则与 \(z_{i - l + 1}\) 的最大性矛盾。因此，每次成功的匹配都会使 \(r\) 增加 \(1\)。时间复杂度是优秀的线性。

2.2 应用

Z 函数可以用于做特定类型的字符串匹配：求字符串 \(t\) 的每个后缀 \(i\) 与 \(s\) 的最长公共前缀长度 \(p_i\)。

• 解法 1：令 \(s' = s + c + t\)，其中 \(c\) 是任意不属于 \(s, t\) 字符集的分隔符。对 \(s'\) 求 Z 函数。
• 解法 2：先求出 \(s\) 的 Z 函数。然后类似求 Z 函数的方法，维护最右匹配段 \([l, r]\) 表示 \(t[l, r] = s[1, r - l + 1]\)，若 \(i > r\) 则暴力匹配，否则令 \(p_i = \min(z_{i - l + 1}, r - i + 1)\)。

两种解法本质相同，因为 Z 算法本身相当于用 \(s\) 匹配自己，类似 KMP 用自己匹配自己的方式求出 \(nxt\) 数组。

2.3 例题

P5410 【模板】扩展 KMP（Z 函数）

#include <bits/stdc++.h>
using namespace std;
const int N = 2e7 + 5;
char s[N], t[N];
int n, m, z[N], p[N];
int main() {
  scanf("%s%s", t + 1, s + 1);
  m = strlen(t + 1), n = strlen(s + 1);
  z[1] = n;
  for(int i = 2, l = 0, r = 0; i <= n; i++) {
    z[i] = i > r ? 0 : min(z[i - l + 1], r - i + 1);
    while(s[1 + z[i]] == s[i + z[i]]) z[i]++; // 因为 i 不等于 1, 所以 i + z[i] 超出下标时空字符和 s[1 + z[i]] 必然不等, 判断句不成立.
    if(i + z[i] - 1 > r) l = i, r = i + z[i] - 1;
  }
  for(int i = 1, l = 0, r = 0; i <= m; i++) {
    p[i] = i > r ? 0 : min(z[i - l + 1], r - i + 1);
    while(p[i] < n && s[1 + p[i]] == t[i + p[i]]) p[i]++; // 应判断 p[i] 小于模式串长度而非匹配串长度.
    if(i + p[i] - 1 > r) l = i, r = i + p[i] - 1;
  }
  long long ans = 0;
  for(int i = 1; i <= n; i++) ans ^= 1ll * i * (z[i] + 1);
  cout << ans << endl;
  ans = 0;
  for(int i = 1; i <= m; i++) ans ^= 1ll * i * (p[i] + 1);
  cout << ans << endl;
  return 0;
}

CF432D Prefixes and Suffixes

KMP 找到完美子串，Z 算法 + 差分求出现次数。

时间复杂度线性。代码。

CF526D Om Nom and Necklace

重新表述题意：若 \(S\) 能被表示成 \(AAA\cdots AB\)，其中 \(A\) 出现了 \(k\) 次且 \(B\) 是 \(A\) 的前缀，则 \(S\) 符合要求。

枚举所有 \(k \mid i\)。根据 border 的性质，若 \(S\) 有长为 \(|S| - p\) 的 border，则 \(S\) 有周期 \(p\)。因此 KMP 求出 \(S\) 的 \(nxt\) 数组。若 \(i - nxt_i \left | \frac i k \right.\) 说明 \(S[1, i]\) 由 \(k\) 个相同字符串拼接而成，即 \(|A| = \frac i k\)。

此时考虑可能的 \(B\) 的最长长度 \(r\)，即 \(\min(|A|, |\mathrm{lcp}(S[i + 1, |S|], S)|)\)，后者用 Z 算法求。这说明 \(S[1, i\sim i + r]\) 均可成为答案，差分维护即可。

时间复杂度线性。代码。

3. 后缀数组

前置知识：计数排序，基数排序，倍增。

后缀数组（Suffix Array, SA）的思想与实现非常简单，基础的倍增思想加上排序，但其扩展得到的 \(ht\) 数组功能强大且适用性广，使得它在 OI 界有广泛应用。

后缀数组在 NOI 大纲里是 8 级算法。

3.1 相关定义

• 定义 \(rk_i\) 表示 \(suf_i\) 在所有后缀中的字典序排名。由于任意后缀长度不同，故不存在两个后缀排名相同。例如 \(\texttt {aabab}\)，有 \(\texttt{aabab} < \texttt{ab} < \texttt{abab} < \texttt{b} < \texttt{bab}\)，所以 \(rk = \{1, 3, 5, 2, 4\}\)。
• 定义 \(sa_i\) 表示排名为 \(i\) 的后缀的开始位置。它与 \(rk\) 互逆：\(rk(sa_i) = i\)，这个 \(i\) 表示排名；\(sa(rk_i) = i\)，这个 \(i\) 表示位置。这就是 后缀数组。

\(rk\) 是从位置到排名的映射，\(sa\) 则将排名映射回位置。若令 \(P\)（Position）表示位置集合，\(R\)（Rank）表示排名集合（均为 \(1\sim n\) 的整数集，但含义不同），则 \(rk\) 可视作 \(P\to R\) 的函数，\(sa\) 可视作 \(R\to P\) 的函数。它们按任意顺序复合均得恒等函数：\(rk \circ sa = sa \circ rk = I\)，其中对于任意 \(x\in [1, n]\) 均有 \(I(x) = x\)。

也可以说，\(rk\) 和 \(sa\) 互为反函数，即 \(rk = sa ^ {-1}\)，\(sa = rk ^ {-1}\)。

充分熟悉 \(rk\) 和 \(sa\) 的定义有助于接下来的学习。

• 简记 \(suf_i\) 和 \(suf_j\) 的最长公共前缀为 \(\mathrm{lcp}(i, j)\)。
• \(ht\) 数组的定义将在 2.3 小节给出，它是 SA 算法的核心。
• 下文区分下标和位置两个概念，前者指数组的某个位置，而后者指某个后缀的开始位置。

3.2 后缀排序

后缀排序算法通过一系列排序操作得到一个字符串的后缀数组。

我们的目标是将字符串 \(s\) 的所有后缀按字典序从小到大排序。

3.2.1 算法介绍

对于两个长度相等的字符串 \(s, t\)，将其分成长度对应相等的两部分 \(s = s_1 + s_2\)，\(t = t_1 + t_2\)（\(|s_i| = |t_i|\)）。如果想比较 \(s\) 和 \(t\) 的字典序大小，可以先比较 \(s_1\) 和 \(t_1\) 的字典序大小，若 \(s_1\neq t_1\)，则 \(s_1\) 和 \(t_1\) 的字典序大小决定了 \(s\) 和 \(t\) 的字典序大小，否则比较 \(s_2\) 和 \(t_2\) 的字典序大小。

对于多个字符串的比较，我们也可以这样做。分成长度对应相等的两部分，以第一部分为第一关键字，第二部分为第二关键字比较。

基于这个思想，我们考虑倍增。

假设已知所有 \(w - 1\) 级子串，即所有 \(s[i, i + 2 ^ {w - 1} - 1]\)（若 \(i + 2 ^ {w - 1} - 1 > n\)，则超出的部分定义为空字符）的排名 \(rk\)。

因为 \(s[i, i + 2 ^ w - 1]\) 等于 \(s[i, i + 2 ^ {w - 1} - 1]\) 加上（拼接）\(s[i + 2 ^ {w - 1}, (i + 2 ^ {w - 1}) + 2 ^ {w - 1} - 1]\)，所以对于位置 \(i\) 和 \(j\)，若 \((rk_i, rk_{i + 2 ^ {w - 1}}) < (rk_j, rk_{j + 2 ^ {w - 1}})\)，则从新的 \(rk'_i < rk'_j\)，即从 \(i\) 开始的 \(w\) 级子串的排名小于从 \(j\) 开始的 \(w\) 级子串的排名。也就是说，\((rk_i, rk_{i + 2 ^ {w - 1}})\) 在所有这样的二元组中的排名反映了 \(s[i, i + 2 ^ w - 1]\) 在所有 \(w\) 级子串中的排名。

进行 \(\mathcal{O}(\log n)\) 层倍增后，所有 \(w\)（\(2 ^ w \geq n\)）级子串互不相同，排序结束。因为两个关键字值域大小均为 \(n\)，所以基数排序配合计数排序即可做到单次倍增 \(\mathcal{O}(n)\)，总复杂度 \(\mathcal{O}(n\log n)\)。

3.2.2 常数优化与注意点

朴素地实现倍增后缀排序常数太大，以下是常数优化技巧。

• 对第二关键字的排序是不必要的：设当前子串长度为 \(2w\)。

  若 \(i + w > n\)，则 \(rk(i + w) = 0\)，\(i\) 在第二关键字排序中被排到最前面；

  对于 \(1\sim n - w\) 的所有位置，我们希望按 \(rk(i + w)\) 递增的顺序排列它们，则 \(i + w\) 在原 \(sa\) 中按下标递增的顺序出现。考虑倒推，按下标 \(i\) 从小到大枚举 \(sa_i\)，若 \(sa_i > w\)，则加入 \(sa_i - w\)。即 \(1\sim n - w\) 在第二关键字排序后的排列，等于所有大于 \(w\) 的 \(sa_i\) 减去 \(w\) 后按下标从小到大排列。

• 计数排序的桶大小：

  修改 \(rk_i\) 的定义为在所有 \(w\) 级子串当中小于 \(s[i, i + w - 1]\) 的 不同的 子串数量加 \(1\)。这样有两个好处，一是计数排序的过程中对桶做前缀和时只需枚举到 \(rk\) 的最大值，即上一轮的 \(rk(sa_n)\)（注意，尽管最终的 \(rk\) 和 \(sa\) 互逆，但后缀排序进行的过程中由于相同排名的存在，并不一定满足该性质），减小常数；二是若 \(rk(sa_n)\) 已经等于 \(n\)，则所有后缀分化完毕，可以直接退出算法而无需等到 \(w \geq n\)。

在实现后缀排序时，还有一些注意点：

• 初始令 \(rk_i = s_i\)，并以 \(s_i\) 为关键字计数排序得到初始 \(sa\)。

• 每次桶排后根据新的 \(sa\) 反推出 \(rk'\)：从小到大枚举 \(i\)，若 \((rk(sa_{i - 1}), rk(sa_{i - 1} + w)) = (rk(sa_i), rk(sa_i + w))\)，则 \(rk'(sa_i) = rk'(sa_{i - 1})\)，否则 \(rk'(sa_i) = rk'(sa_{i - 1}) + 1\)。在此之前需要将原 rk 数组拷贝一份到 ork，否则更新 rk 时会出错。

给出一份实现良好的后缀排序 模板题 代码，附有部分注释：

#include <bits/stdc++.h>
using namespace std;
constexpr int N = 1e6 + 5;
char s[N];
int n, sa[N], rk[N], ork[N], buc[N], id[N];
void build() {
  int m = 1 << 7, p = 0;
  for(int i = 1; i <= n; i++) buc[rk[i] = s[i]]++;
  for(int i = 1; i <= m; i++) buc[i] += buc[i - 1];
  for(int i = n; i; i--) sa[buc[rk[i]]--] = i;
  for(int w = 1; ; m = p, p = 0, w <<= 1) { // m 表示桶的大小, 等于上一轮的 rk 最大值.
    for(int i = n - w + 1; i <= n; i++) id[++p] = i; // 循环顺序无关, 顺序倒序都可以, 不影响最终结果.
    for(int i = 1; i <= n; i++) if(sa[i] > w) id[++p] = sa[i] - w;
    memset(buc, 0, m + 1 << 2); // 注意清空桶.
    memcpy(ork, rk, n + 1 << 2); // 注意拷贝 rk -> ork.
    p = 0;
    for(int i = 1; i <= n; i++) buc[rk[i]]++;
    for(int i = 1; i <= m; i++) buc[i] += buc[i - 1];
    for(int i = n; i; i--) sa[buc[rk[id[i]]]--] = id[i]; // 注意, 倒序枚举保证计数排序的稳定性. 基数排序的正确性基于内层计数排序的稳定性.
    for(int i = 1; i <= n; i++) rk[sa[i]] = ork[sa[i - 1]] == ork[sa[i]] && ork[sa[i - 1] + w] == ork[sa[i] + w] ? p : ++p; // 原排名二元组相同则新排名相同, 否则排名 +1.
    if(p == n) break; // n 个排名互不相同, 排序完成.
  }
}
int main() {
  scanf("%s", s + 1);
  n = strlen(s + 1);
  build();
  for(int i = 1; i <= n; i++) printf("%d ", sa[i]);
  return 0;
}

• 尽管上述代码中 sa[i - 1] + w 和 sa[i] + w 可能达到 \(2n\)，但 ork 的大小只需要开到 \(n + 1\)：若 ork[sa[i - 1]] != ork[sa[i]]，则程序不会执行第二条判断，直接返回否。否则 ork[sa[i - 1]] = ork[sa[i]]，说明 \(s[sa_{i - 1}, sa_{i - 1} + w - 1] = s[sa_i, sa_i + w - 1]\)，据此可知 \(sa_{i - 1} + w - 1\) 和 \(sa_i + w - 1\) 均 \(\leq n\)，因此 \(sa_{i - 1} + w\) 和 \(sa_i + w\) 均 \(\leq n + 1\)。

3.3 Height 数组

• 定义 \(ht_i\) 表示 \(suf(sa_{i - 1})\) 与 \(suf(sa_i)\) 的最长公共前缀长度 \(|\mathrm{lcp}(sa_{i - 1}, sa_i)|\)，即排名为 \(i - 1\) 和 \(i\) 的后缀的 LCP 长度。\(ht_1\) 未定义，一般为 \(0\)。

绝大多数 SA 的应用都需要 \(ht\) 数组的信息，很少见只用 \(sa\) 和 \(rk\) 就可以解决的问题。不过分地说，后缀排序求 \(sa\) 和 \(rk\) 只是为了求 \(ht\)。

求 \(ht\) 用哈希 + 二分 LCP 太 low 了不是吗？完全没用上 \(sa\) 和 \(rk\) 的优秀性质。

结论 1：若 \(rk_i < rk_j < rk_k\)，则 \(|\mathrm{lcp}(i, j)|\) 和 \(|\mathrm{lcp}(j, k)|\) 均不小于 \(|\mathrm{lcp}(i, k)|\)。

证明：设 \(t = |\mathrm{lcp}(i, k)|\)，因为 \(suf_j\) 的字典序在 \(suf_i\) 和 \(suf_k\) 之间，所以 \(suf_j\) 的前 \(t\) 个字符必然和 \(suf_i\) 与 \(suf_k\) 相等。\(\square\)

结论 1 非常容易理解，因为字典序距离越近，LCP 越长。例如，按字典序排序后，两个 \(\tt abcd\) 开头的字符串之间不会出现以 \(\tt abcc\) 或 \(\tt abce\) 开头的字符串。

若希望求出 \(ht\) 数组，自然考察其性质。

假设 \(ht_i\) 已知，则 \(|\mathrm{lcp}(sa_i, sa_{i - 1})| = ht_i\)。考察 \(suf(sa_{i - 1} + 1)\) 和 \(suf(sa_i + 1)\)，即排名分别为 \(i - 1\) 和 \(i\) 的后缀位置加上 \(1\) 后对应的后缀。当 \(ht_i > 0\) 时，显然有 \(|\mathrm{lcp}(sa_{i - 1} + 1, sa_i + 1)| = ht_i - 1\)，且根据 \(rk(sa_{i - 1}) < rk(sa_i)\) 容易证明 \(rk(sa_{i - 1} + 1) < rk(sa_i + 1)\)。

令 \(p\) 和 \(q\) 分别表示排名为 \(i\) 和 \(i - 1\) 的后缀位置加 \(1\)，即 \(sa_i + 1\) 和 \(sa_{i - 1} + 1\)，我们尝试求出 \(rk_p\) 对应的 \(ht\)。先梳理一下已有的信息：

• \(|\mathrm{lcp}(q, p)| = ht_i - 1\)。
• \(rk_q < rk_p\)。

它们合起来表达了：存在位置 \(q\)，满足其排名小于 \(p\) 的排名，且它们对应后缀的 LCP 长度为 \(ht_i - 1\)。

相信部分读者此时已经想到一些了不起的性质了。

排名为 \(rk_p - 1\) 的后缀 \(suf_r\) 的排名要么等于 \(rk_q\)，此时 \(q = r\)，要么夹在 \(rk_q\) 和 \(rk_p\) 之间，因为 \(rk_r\) 是小于 \(rk_p\) 的最大正整数 \(rk_p - 1\)，而 \(rk_q\) 小于 \(rk_p\)。因此，根据结论 1，其与 \(p\) 之间的 LCP 长度必然不小于 \(ht_i - 1\)，即 \(ht(rk_p) \geq ht_i - 1\)。

进一步地，注意到 \(rk_p\) 表示排名为 \(i\) 的后缀位置加 \(1\) 的排名，\(i\) 表示排名为 \(i\) 的后缀位置的排名，即 \(ht(rk(sa_i + 1)) \geq ht(rk(sa_i)) - 1\)。换元，令 \(u = sa_i + 1\)，我们得到了 \(ht\) 数组的核心性质（\(u > 1\)）：

\[\color {red} {\boldsymbol {ht(rk_u) \geq ht(rk_{u - 1}) - 1}} \]

• 没有讨论 \(ht_i = 0\) 的情况，不过因为 \(ht\) 非负所以同样满足上式。
• 因为 \(s_0\) 为空字符，所以求出的 \(ht(1) = 0\)。

如上图，\(p = sa_i + 1\)，\(q = sa_{i - 1} + 1\)，\(ht_i - 1 = |\mathrm{lcp}(p, q)| \leq |\mathrm{lcp}(p, r)| = ht(rk_p)\)。

根据该性质，我们可以按 \(i\) 递增的顺序递推求解 \(ht(rk_i)\)。实际上就是按 \(i\) 从小到大的顺序计算位置为 \(i\) 的后缀与排名为其排名减 \(1\) 的后缀的 \(\mathrm{lcp}\)。想象一个指针从 \(s_1\) 扫到 \(s_n\)，指针右移时，将右移前排名减 \(1\) 的后缀对应位置也向右移动一位，就可以理解 \(ht\) 数组的性质了。

下方代码中，\(k\) 指针向右移动的总次数为线性，因为每次 \(i\) 增加只会使得 \(k\) 减少 \(1\)，而 \(k \leq n\)。

for(int i = 1, k = 0; i <= n; i++) {
  if(k) k--;
  while(s[i + k] == s[sa[rk[i] - 1] + k]) k++; // sa[rk[i]] = i, 需要保证 s[0] 和 s[n + 1] 为空字符 (多测清空), 否则可能出错.
  ht[rk[i]] = k;
}

3.4 应用

3.4.1 求任意两个后缀的 LCP

有了 \(ht\) 数组，我们可以快速求一个字符串 \(s\) 的 \(i\) 后缀与 \(j\) 后缀的最长公共前缀 \(\mathrm{lcp}(i, j)\)。

结论 2：设 \(rk_i < rk_j\)，则 \(|\mathrm{lcp}(i, j)| = \min_{p = rk_i + 1} ^ {rk_j} ht_p\)。

证明：设 \(t = |\mathrm{lcp}(i, j)|\)。

根据字典序的定义，所有排名在 \(rk_i\) 和 \(rk_j\) 之间的后缀 \(suf_k(rk_i \leq rk_k \leq rk_j)\) 的前 \(t\) 个字符均与 \(suf_i\) 和 \(suf_j\) 相等。又因为 \(suf_i[t + 1] \neq suf_j[t + 1]\)，所以存在两个相邻的排名 \(p, p + 1\)，使得 \(suf(sa_p)[t + 1] \neq suf(sa_{p + 1})[t + 1]\)。这样，对于所有 \(p \in [rk_i + 1, rk_j]\)，\(ht_p \geq t\)，且存在 \(ht_p = t\)。\(\square\)

简单地说，\(i\) 后缀与 \(j\) 后缀的最长公共前缀长度就是夹在这两个后缀排名之间的 \(ht\) 数组的最小值。可以感性理解为字典序相差越大，前缀差别越大。

上图为对 \(\tt aabaaaab\) 后缀排序的结果及其 \(ht\) 数组，由矩形框起来的两个字符串相等。形象地，两个后缀之间的 \(\rm \mathrm{lcp}\) 就是它们排名之间所有矩形宽度的最小值，即 \(ht\) 的最小值。

如果将整张图逆时针旋转 \(90\) 度，将得到一张矩形柱状图。\(ht\) 恰好表示了每个矩形的高度，这可能也是 height 这一名称的来源。正因如此，SA 可以和单调栈相结合：众所周知，单调栈可以求出柱状图中面积最大的矩形。

查询区间最值，使用 ST 表维护即可做到 \(\mathcal{O}(n\log n)\) 预处理，\(\mathcal{O}(1)\) 在线回答询问。

注意点：

• 查询范围是 \(rk_i, rk_j\) 而非 \(i, j\)。
• 当 \(rk_i > rk_j\) 时，需要 swap(i, j)。
• 左边界要加 \(1\)。
• 需特判 \(i = j\) 的情况。

3.4.2 求本质不同子串数

可以用 \(s\) 的所有后缀的所有前缀表示其所有子串。考虑每次添加一个后缀，并删去这个后缀与已经添加的后缀的所有重复前缀，即 \(\max_{j\in S} |\mathrm{lcp}(s_i, s_j)|\)。

因为 \(\max_{j < i}|\mathrm{lcp}(sa_i, sa_j)| = |\mathrm{lcp}(sa_i, sa_{i - 1})| = ht_i\)，所以按照 \(sa_1, sa_2, \cdots, sa_n\) 的顺序添加后缀，\(sa_i\) 对答案的贡献即 \((n - sa_i + 1) - ht_i\)。化简得

\[\binom {n + 1} 2 - \sum_{i = 2} ^ n ht_i \]

上述做法求出了 \(s\) 的所有后缀的本质不同前缀数量。我们可以将其扩展到求 \(s\) 的某个后缀集合 \(S\) 的所有本质不同前缀数量。设 \(S\) 的所有元素（位置）按排名从小到大排序后分别为 \(p_1, p_2, \cdots, p_{|S|}\)，类似地，答案为

\[\left(\sum_{i = 1} ^ {|S|} n - p_i + 1 \right) - \left(\sum_{i = 1} ^ {|S| - 1} |\mathrm{lcp}(p_i, p_{i + 1})|\right) \]

后者对 \(ht\) 预处理 ST 表后 \(\mathcal{O}(|S|)\) 求出。

3.4.3 结合单调栈

\(ht\) 数组可以被形象地认为是一张矩形柱状图，这是用单调栈解决问题的基础。

例如求所有后缀两两 LCP 长度之和，考虑按排名顺序加入所有后缀并实时维护 \(F(i) = \sum_{p = 1} ^ {i - 1}|\mathrm{lcp}(sa_p, sa_i)|\)，即 \(\sum_{p = 1} ^ {i - 1}\min_{q = p + 1} ^ i ht_q\)，可以视为往单调栈内加入高 \(ht_i\)，宽 \(1\) 的矩形后，单调栈内矩形面积之和。这容易维护的。

对所有 \(F(i)\) 求和即为所求。例题如 P4248，P7409 和 CF1073G。

3.4.4 多个串的最长公共子串

给定 \(n\)（\(n > 1\)）个字符串 \(s_1, s_2, \cdots, s_n\)，求它们的最长公共子串。

令 \(t = s_1 + c_1 + s_2 + c_2 + \cdots c_{n - 1} + s_n\)，\(L = |t|\)，表示将所有字符串拼接起来，并用不属于字符集的分隔符隔开。对 \(t\) 建出 SA 数组，问题相当于求 \(\max_{1 \leq l \leq r \leq L} \min_{p = l + 1} ^ r |\mathrm{lcp}(p, p - 1)|\)，其中 \(l, r\) 需满足每个字符串 \(s_i\) 均有一个后缀落在排名区间 \([l, r]\) 内，因为子串需要同时出现在每个字符串当中。

容易发现随着 \(l\) 增大，\(r\) 单调不降，即若 \([l, r]\) 满足限制，则 \([l', r']\)（\(l'\leq l\)，\(r \leq r'\)） 同样合法。因此用双指针维护整个过程。此外，我们需要实时维护区间最小值，根据端点单调性，使用单调队列即可。

双指针部分复杂度线性。例题如 P2463。

3.4.5 结合并查集

注意到两个后缀之间的 LCP 长度以它们排名之间的 \(ht\) 的最小值表示，所以当给定长度阈值 \(L\) 时，去掉所有 \(< L\) 的 \(ht\) 将排名区间划分成若干子区间，同一子区间内任意两个后缀的 LCP 长度均 \(\geq L\)。

从大到小考虑所有 \(ht_i\)，每次在 \(sa_{i - 1}\) 和 \(sa_i\) 之间连边并使用数据结构如 Kruskal 重构树或并查集 + 启发式 / 线段树合并维护这一过程，可以得到与每个后缀的 LCP 长度 \(\geq L\) 的所有后缀的信息。

对 \(ht_i\) 建笛卡尔树效果相同。

例题如 P2179，P7361。

3.5 例题

P3763 [TJOI2017] DNA

枚举开始位置并使用 SA 加速匹配。时间复杂度线性对数。代码。

P2852 [USACO06DEC] Milk Patterns G

从大到小添加每个 \(ht_i\)，等价于在 \(sa_i\) 和 \(sa_{i - 1}\) 连边，使得出现大小为 \(k\) 的连通块的 \(ht_i\) 即为所求。

P2463 [SDOI2008] Sandy 的卡片

差分后求所有 \(n\) 个数组的最长公共子串，双指针加单调队列实现，2.4.4 有讲解。时间复杂度线性对数。代码。

SP220 PHRASES - Relevant Phrases of Annihilation

建出 SA 数组，二分答案，检查每个 \(ht \geq mid\) 的极长排名区间是否合法。时间复杂度 \(\mathcal{O}(S \log S)\)，其中 \(S = \sum |s_i|\)。

P4248 [AHOI2013] 差异

令 \(F(i)\) 表示排名为 \(i\) 的后缀与排名小于它的后缀之间的 LCP 长度之和。

将 \(ht_i\) 看成宽 \(1\) 高 \(ht_i\) 的矩形，则 \(F(i) = \sum_{p = 1} ^ {i - 1} \min_{j = p + 1} ^ i ht_j\)，即 \(ht_{1\sim i}\) 组成的高度递增的单调栈内矩形面积和。用单调栈维护 \(F\)，依次求出 \(F(2\sim n)\)，答案即

\[\dbinom{n + 1} 2(n - 1) - 2\sum_{i = 2} ^ n F(i) \]

时间复杂度线性对数，代码。

P7409 SvT

双倍经验。

CF1073G Yet Another LCP Problem

三倍经验。

求出 \(\sum_{rk(a_i) < rk(b_j)} |\mathrm{lcp}(a_i, b_j)|\) 以及反过来的结果，再加上 \(a_i = b_j\) 的 \(\sum n - a_i + 1\)。

将 \(a_i\) 和 \(b_j\) 按照 \(rk\) 排序，若 \(b_j = a_i\) 则认为 \(b_j\) 在前，因为限制 \(rk(a_i) < rk(b_j)\)。若当前是 \(a_i\)，则先将单调栈内高于 \(|\mathrm{lcp}(a_{i - 1}, a_i)|\) 的部分削去，再加入高 \(n - a_i + 1\) 的矩形，前者可以视为加入宽 \(0\)，高 \(|\mathrm{lcp}(a_{i - 1}, a_i)|\) 的矩形。若当前是 \(b_j\)，则将单调栈内高于 \(|\mathrm{lcp}(a_i, b_j)|\) 的部分削去，并将面积累和入答案，其中 \(a_i\) 是上一个被考虑到的 \(a\)。

时间复杂度 \(\mathcal{O}((n + \sum k + l)\log n)\)。代码。

P4081 [USACO17DEC] Standing Out from the Herd P

将所有字符串用 不同 分隔符连接，后缀排序，对于颜色相同的一段排名区间 \([l, r]\)，先求出在考虑之前排名的后缀时，每个后缀的贡献 \(L_i - ht_i\)，其中 \(L_i\) 表示排名为 \(i\) 的后缀长度。

这样，这段排名区间对答案的贡献还要减去 \(suf_{sa_r}\) 和 \(suf_{sa_{r + 1}}\) 之间的 LCP 长度 \(ht_{r + 1}\)，再加上多减的部分，即 \(suf_{sa_{l - 1}}\) 和 \(suf_{sa_{r + 1}}\) 之间的 LCP 长度。

时间复杂度 \(\mathcal{O}(n\log n)\)。代码。

P6640 [BJOI2020] 封印

求出 \(s\) 的每个后缀最长的作为 \(t\) 的子串的前缀长度，设为 \(f_i\)。问题相当于求 \(\max_{i = l} ^ r \min(r - i + 1, f_i)\)。

直接二分答案 \(x\)，检查是否有 \(\max_{i = l} ^ {r - x + 1} f_i \geq x\) 即可。时间复杂度线性对数。代码。

*P2178 [NOI2015] 品酒大会

由于 \(r\) 相似也是 \(r'\)（\(0\leq r < r\)） 相似，所以如果仅考虑 \(\geq L\) 的 \(ht_i\)，将 \(sa_{i-1}\) 和 \(sa_i\) 之间连边，若 \(p, q\) 在同一连通块，说明 \(\mathrm{lcp}(suf_p, suf_q)\geq L\)，即 \(p,q\) 是 “\(L\) 相似” 的。

这启发我们求出 \(ht\) 后从大到小依次处理，并使用并查集和启发式合并实时维护每个连通块的大小以及所有权值。只需用最大值乘以次大值，以及最小值乘以次小值（因为有负数）更新 \(L\) 的答案，时间复杂度 \(\mathcal{O}(n\log ^ 2 n)\)。

进一步地，只记录四个极值就不需要启发式合并 set，时间复杂度 \(\mathcal{O}(n\log n)\)。

*CF822E Liar

使用贪心的思想可知在一轮匹配中，我们能匹配尽量匹配，即若从 \(s_i\) 和 \(t_j\) 开启新的一段，那么我们一定会匹配直到第一个 \(k\) 使得 \(s_{i + k} \neq t_{j + k}\)。因为匹配到一半就断掉没有匹配到不能继续为止更优。若前者存在符合题意的分配方案，则后者必然存在，调整法易证。

注意到 \(x\leq 30\) 的限制，说明总状态数不会很多，考虑动态规划。

设 \(f_{i, j}\) 表示 \(s[1, j]\) 选出 \(i\) 个子串时最多能匹配到 \(t\) 的哪个位置。对于每个 \(f_{i, j}\)，首先可以转移到 \(f_{i, j + 1}\) 表示不开启一段匹配。若开启一段匹配，则需找到 \(s[j + 1, n]\) 和 \(t[f_{i - 1, j} + 1, m]\) 的最长公共前缀长度 \(L\)，并令 \(f_{i, j + L} \gets \max(f_{i, j + L}, f_{i - 1, j} + L)\)。

求一个字符串某两个后缀的 LCP 是后缀数组的拿手好戏，时间复杂度 \(\mathcal{O}(n(x + \log n))\)。代码。

本题同时用到了贪心，DP 和 SA 这三个跨领域的算法，是好题。

P5028 Annihilate

设排名 \(j\) 对应字符串 \(bel_j\)。

枚举每个字符串 \(s_i\)，每个排名 \(j\) 对 \(ans(i, bel_j)\) 的贡献为 \(\max(|\mathrm{lcp}(j, pre)|, |\mathrm{lcp}(j, suf)|)\)，其中 \(pre\) 表示 \(j\) 的属于字符串 \(i\) 的排名前驱，\(suf\) 则为后继。

因此，从小到大枚举排名 \(j\) 并实时维护 \(mn = |\mathrm{lcp}(j, pre)|\)，相当于 \(ht\) 的一段区间 \(\min\)。若 \(bel_j = i\)，则 \(pre\) 变为 \(j\)，将 \(mn\) 设为 \(+\infty\)；

否则 \(mn\gets \min(mn, ht_j)\)，然后令 \(ans(i, bel_j)\gets \max(ans(i, bel_j), mn)\)。反过来再做一遍即可。

这样避免空间复杂度带 \(\log\)。时间复杂度 \(\mathcal{O}(L(n + \log L))\)。代码。

P7769 丑国传说 · 大师选徒（Selecting Apprentices）

考虑 \(a_{l+k} + a_{b + k} = s\) 的充要条件：设 \(d_i = a_{i + 1} - a_i\)，\(d_n\) 未定义，需满足 \(a_l + a_b = s\) 且 \(d_{l\sim r - 1}\) 与 \(d_{b\sim b + (r - l) - 1}\) 互为相反数。

这启发我们把 \(d\) 以及 \(d\) 的相反数 \(d'\) 拼接在一起得到序列 \(D\)。求出其后缀数组，问题转化为检查是否存在 \(D\) 的后缀 \(D[i, 2n - 1]\) 满足 \(i > n\) 且 \(a_{i - n} = s - a_l\) 且 \(|\mathrm{lcp}(D[i, 2n - 1], D[l, 2n - 1])| \geq r - l\)。

容易处理第三条限制：符合条件的后缀的排名是一段包含 \(rk_l\) 的区间 \([x, y]\)（\(x\leq rk_l\leq y\)）。预处理 \(ht\) 的倍增数组，二分 + RMQ 求出。

对于前两条限制，对每个值 \(c\) 开桶 \(buc_c\) 记录 \(i > n\) 且 \(a_{i - n} = c\) 的所有 \(i\) 后缀的排名。询问即检查 \(buc_{s - a_l}\) 中是否存在 \([x, y]\) 之间的数，排序后二分查找即可。注意特判 \(l = r\) 的情况。

时空复杂度均为线性对数。代码。

P2603 [ZJOI2008] 无序运动

这道题的关键在于如何处理两个粒子片段相似。设两粒子片段分别为 \((a_1, \cdots, a_k)\) 和 \((b_1, \cdots, b_k)\)，设 \(A_i = \overrightarrow{a_ia_{i + 1}}\)，记 \(f(a) = A\)，\(B_i\) 同理，得到两个向量序列 \(A, B\)。

容易得知，不考虑翻转时，\(a\) 相似于 \(b\) 当且仅当对于任意 \(i\in [1, k - 2]\)，有序对 \((A_i, A_{i + 1})\) 和 \((B_i, B_{i + 1})\) 相似，体现为它们的长度比相等 \(\frac {|A_i|}{|A_{i + 1}|} = \frac {|B_i|}{|B_{i + 1}|}\)，且 有向 夹角相等 \(\lang A_i, A_{i + 1}\rang = \lang B_i, B_{i + 1}\rangle\)。

用浮点数记录上述信息丢失精度，考虑记录向量长度的平方比，以及向量叉积与点积的比。一个细节，就是叉积比点积得到夹角正切值，但 \(\tan\) 的周期是 \(\pi\)，无法唯一对应一个 \(2\pi\) 范围内的角度。此时我们需要保留叉积的符号，即约分时最大公约数取绝对值。

考虑翻转只需将 \(a_i\) 关于 \(x\) 或 \(y\) 轴对称，再做一遍上述判定即可。

因此，我们得到如下算法：用相邻向量之间的信息描述所有片段和粒子运动轨迹。类似字符串匹配，将信息离散化后容易使用 SA 或 AC 自动机求出每个片段在粒子运动轨迹和粒子运动轨迹关于 \(y\) 轴对称得到的轨迹中出现次数之和。

注意点：

• 特判 \(k = 2\)。
• 当某个片段翻转后与它本身不考虑翻转相似时，它在原粒子运动轨迹中每出现一次均会在翻转后的粒子运动轨迹的对应位置出现，被重复计算。因此要除以 \(2\)。

时间复杂度 \(\mathcal{O}((N + L) \log (n + L))\)。代码。

P6095 [JSOI2015] 串分割

因为字符不含 \(0\)，所以贪心让最大位数最小。答案串长度 \(L = \left \lceil \frac n k \right\rceil\)。

答案满足可二分性。我们二分答案在后缀数组中的排名。破环成链，枚举 \(L\) 个起始点并判断是否可行。假设当前匹配到 \(i\)，若 \(s[i, i + L - 1]\) 的排名不大于二分的答案，那么就匹配 \(L\) 位，否则匹配 \(L - 1\) 位。若进行 \(k\) 次匹配后总匹配位数不小于 \(n\) 则可行。

若可匹配 \(L\) 位时匹配 \(L - 1\) 位，则下一次最多匹配 \(L\) 位，这与首先匹配 \(L\) 位时下一次匹配的最劣情况，即匹配 \(L - 1\) 位，效果相同。因此贪心正确。

进一步地，比较两个长度为 \(L\) 的字符串时，我们不需要求 LCP 并比较下一个字符。可直接比较它们对应的后缀。问题在于也许 \(s[i, i + L - 1]\) 和 \(s[j, j + L - 1]\) 相等，其中 \(j\) 是排名为当前二分值的后缀开始位置，但 \(suf_i > suf_j\)，这使得我们认为只能匹配 \(L - 1\) 位而非 \(L\) 位。

但其实没有关系，因为若 \(s[j, j + L - 1]\) 作为答案串可行，则二分排名最大的以 \(s[j, j + L - 1]\) 作为前缀的后缀时必然可行。

时间复杂度 \(\mathcal{O}(n\log n)\)。代码。

*P6793 [SNOI2020] 字符串

对 \(a + b\) 求后缀数组。类似品酒大会的套路，按 \(ht\) 大到小合并相邻两个排名的后缀，然后贪心消灭掉当前连通块尽可能多的 \(a, b\) 后缀对。

时间复杂度 \(\mathcal{O}(n\log n)\)。代码。

P2336 [SCOI2012] 喵星球上的点名

将姓和名用分隔符连接，问题相当于给定 \(n\) 个文本串和 \(m\) 个模式串，对每个文本串求出作为其子串的模式串数量，对每个模式串求出包含它为子串的文本串数量。这是 AC 自动机经典应用，但因为字符集太大（也可以做），考虑其它做法。

将所有文本串用分隔符连接，建出后缀数组，对每个模式串求出以其为前缀的排名区间。第一问相当于区间不同颜色数，离线扫描线 BIT。第二问相当于对每种颜色查询与其有交的区间数。对每个区间和每个颜色在第一个位置统计答案，则每个位置对其对应的颜色的贡献为左端点落在一段区间，右端点落在另一段区间的区间数量，二维数点，离线扫描线 BIT。

时间复杂度线性对数。代码。

P4143 采集矿石

字典序排名从大到小使得对于固定的 \(l\)，随着 \(r\) 增大，\([l, r]\) 的排名 严格递减，重要度之和 非严格递增。只需二分出 \([l, r]\) 的排名与重要度之和的交点，再检查是否符合要求。

考虑如何求某个子串 \([l, r]\) 在所有本质不同子串中的排名。对于子串 \([l', r']\)，其字典序 非严格大于 \([l, r]\) 当且仅当后者是前者的前缀，或者去掉 LCP 后前者的第一个字符大于后者。

满足第一种条件的子串对应后缀 \([l', n]\) 的排名是一段排名区间 \([L, R]\)（\(L \leq \mathrm{rank}(l) \leq R\)）。满足第二种条件的子串对应后缀的排名是排名区间 \([R + 1, n]\)。

因此，求出排名为 \([L, n]\) 的后缀的本质不同前缀数量，减去 \(r - l\)（\([l, r]\) 的真前缀被多算了）即为所求。前者根据后缀数组经典结论，为 \(\left(\sum_{i = L} ^ n n - sa_i +1 \right) - \left(\sum_{i = L + 1} ^ n ht_i\right)\)。

求出 \(L\) 只需二分找到不大于 \(rk_l\) 的最小排名，使得排名为 \(L\sim rk_l\) 之间所有后缀的 LCP 不小于 \(r - l + 1\)。对 \(ht\) 预处理 ST 表求 RMQ + 二分即可。

时间复杂度 \(\mathcal{O}(n\log ^ 2 n)\)。代码。

*CF1654F Minimal String Xoration

非常好题目，爱来自瓷器。

注意到一个重要性质，位运算在每一位独立。

设 \(f(i, d)\) 表示 \(s_is_{i \oplus 1}s_{i\oplus 2} \cdots s_{i\oplus (2 ^ d - 1)}\)，即 \(s\) 的下标异或 \(i\) 得到字符串的前 \(2 ^ d\) 位。可知 \(f(i, d + 1) = f(i, d) + f(i \oplus 2 ^ d, d)\)。

因此，类似后缀排序，设 \(p(i, d)\) 表示 \(f(i, d)\) 在所有 \(f(j, d)\)（\(0\leq j < 2 ^ n\)）当中的排名，则 \(p(i, d + 1)\) 即为二元组 \((p(i, d), p(i \oplus 2 ^ d, d))\) 在所有二元组 \((p(j, d), p(j \oplus 2 ^ d, d))\) 中的排名。

倍增并排序，时间复杂度 \(\mathcal{O}(2 ^ nn ^ 2)\)。使用基数排序可以去掉一个 \(n\)，但并不必要。代码。

*P7361 「JZOI-1」拜神

不错的题目。

建出 \(s\) 的后缀数组，考虑一次询问的本质。对于长度 \(L\)，它合法当且仅当存在两个位置 \(p, q \in [l, r - L + 1]\)（\(p\neq q\)），使得 \(\mathrm{lcp}(suf_p, suf_q)\geq L\)。根据套路，\(p, q\) 满足该条件当且仅当若将所有 \(\geq L\) 的 \(ht_i\) 值对应的两个位置 \(sa_{i - 1}\) 与 \(sa_i\) 之间连边，则 \(p, q\) 在同一连通块。

显然答案满足可二分性，因此着眼于判断一个长度 \(L\) 是否合法。借鉴品酒大会的技巧，我们求出 \(ht\) 数组后从大到小加入并查集，相当于每次合并两个位置 \(sa_{i - 1}, sa_i\)。对于每个长度 \(L\)，在线段树 \(T_L\) 上记录每个位置 \(p\) 的后继 \(suc_p\)，表示 \(suc_p\) 是大于 \(p\) 且和 \(p\) 在相同连通块的最小位置。判断合法只需查询 \(T_L\) 上 \([l, r - L]\) 的区间最小值是否 \(\leq r - L + 1\)。

考虑如何维护 \(suc_p\)：启发式合并。为并查集的每个代表元维护一个 set \(S_i\)，每次往 \(S_i\) 中插入一个数 \(y\)，lower_bound 查询 \(y\) 的后继 \(su\) 与前驱 \(pr\)，在线段树上更新 \(suc_{pr} \gets y\) 且 \(suc_y \gets su\)。由于要储存每个长度的线段树，所以可持久化。

时空复杂度均为线性对数平方。代码。

*P5161 WD 与数列

据定义，差分数组相同的两个串相等。转化为求差分数组不相交且不相邻的相等子串对数量，补集转化得相等子串对数量减去相交或相邻的相等子串对数量。

对差分数组求后缀数组，按 \(ht\) 从大到小合并相邻两个排名的后缀。用线段树与启发式合并求出两个后缀所在连通块 \(X, Y\) 之间的两两贡献，即 \(\sum_{x \in X} \sum_{y \in Y} \max(0, w + 1 - |x - y|)\)，其中 \(w\) 为当前 \(ht\)。遍历较小集合 \(Y\) 的每个位置 \(y\)，在线段树 \(T_X\) 上查询 \([y - w, y)\) 以及 \((y, y + w]\) 两个区间位置个数与下标之和。最后线段树合并。

时间复杂度 \(\mathcal{O}(n\log ^ 2 n)\)，空间复杂度 \(\mathcal{O}(n\log n)\)。代码。

P5115 Check, Check, Check one two!

看到题目，我首先想到建出正反串 SA 及其 \(ht\) 的笛卡尔树，并在一棵树上启发式合并，另一棵树上用 P4211 LCA 套路做，掐指一算发现时间复杂度是 \(\mathcal{O}(n\log ^ 3 n)\)，虽然离线（枚举 LCA，考虑较小子树对较大子树的贡献，将询问离线扫描线）后三个 \(\log\) 分别是启发式合并，BIT 和树剖，显然卡不满，但是依然非常难写。

稍微观察一下 \(\mathrm{lcp}(i, j)\) 和 \(\mathrm{lcs}(i, j)\)，它们拼接起来形成长为 \(\mathrm{lcp}(i, j) + \mathrm{lcs}(i, j) - 1\) 的相等子串，联想到优秀的拆分，这启发我们在 \((i - \mathrm{lcs}(i, j) + 1, j - \mathrm{lcs}(i, j) + 1)\) 处统计贡献。因为相等子串的要求 极长，否则 \(\mathrm{lcp}(i, j)\) 或 \(\mathrm{lcs}(i, j)\) 可以更大，所以枚举 \(i, j\)，若 \(s_{i - 1} \neq s_{j - 1}\)，则 \(s[i, i + \mathrm{lcp}(i, j) - 1]\) 产生贡献。进一步地，我们发现贡献和 \(i, j\) 具体无关，仅和 \(L = \mathrm{lcp}(i, j)\) 相关，为 \(f(L) = \sum_{p = 1} ^ L p(L - p + 1) [p\leq k_1][L - p + 1 \leq k_2]\)。\(f\) 可以 \(\mathcal{O}(n)\) 预处理。

对于 \(s_{i - 1} \neq s_{j - 1}\) 的要求，直接容斥。问题转化为求与任意两个 \((i, j)\)（\(i < j\)）的 \(\mathrm{lcp}(i, j)\) 相关的式子。经典套路，直接对 \(ht\) 做扫描单调栈，对于当前 \(i\) 实时维护 \(\sum_{1\leq j < i} f(\min_{p = j + 1} ^ i ht_p)\) 即可。时间复杂度 \(\mathcal{O}(n(\log n + |\Sigma|))\)。代码。

理论可以做到关于长度加字符集线性（线性 SA，线性区间 RMQ），但不实用。

听说官方题解是 \(\log ^ 2 n\) 的边分树，应该是对题解一开始的 \(\log ^ 3 n\) 思路应用更多套路。对比两种做法，直接硬做没有用到拼接成相等子串的性质，而扫描单调栈巧妙运用了该性质。对于前者，可以扩展至无法拼接的问题而后者不能，如给定排列 \(p\)，将原问题 \(\mathrm{lcp}(i, j)\) 换成 \(\mathrm{lcp}(p_i, p_j)\)。对于后者，可以扩展至任意容易快速计算 \(f\) 的情形，如 \((\mathrm{lcp}(i, j) \mathrm{lcs}(i, j)) ^ k\)。

*P1117 [NOI2016] 优秀的拆分

本题巧妙的地方有两点，一是通过乘法原理将 \(AABB\) 转化为以每个位置开头和结尾的 \(AA\) 数量 \(g_i / f_i\)，二是枚举 \(A\) 的长度 \(L\)，设置关键点 求 \(f\) 和 \(g\)。

对于固定的 \(L\)，若每间隔 \(L\) 放置一个关键点，则 \(AA\) 必然恰好经过两个关键点。不妨设为 \(p\) 和 \(q = p + L\)。我们在 \(q\) 处统计 \(f_i\)，在 \(p\) 处统计 \(g_i\)，即可能的开始位置，且 \(q\) 管辖的右端点（结尾位置）范围为 \([q, \min(n, q + L - 1)]\)，\(p\) 管辖的左端点（开始位置）范围为 \([\max(1, p - L + 1), p]\)。

求出 \(suf_p\) 和 \(suf_q\) 的最长公共前缀长度 \(r\)，以及 \(pre_p\) 和 \(pre_q\) 的最长公共后缀长度 \(l\)。

\(l\) 限制了 \(AA\) 开头和末尾的最小值。\(pre_p\) 和 \(pre_q\) 的 LCS 只有 \(l\)，所以对于任意 \(i\in [p - l + 1, p]\) 均有 \(s_i = s_{i + L}\)，但 \(s_{p - l}\neq s_{q - l}\)。因此，\(AA\) 的开头位置不能在 \(p - l + 1\) 左边，对应末尾位置不能在 \((p - l + 1) + 2L - 1\) 即 \(q + L - l\) 左边。

同理，\(AA\) 末尾的最大值不能超过 \(q + r - 1\)，对应开头位置不能在 \((q + r - 1) - 2L + 1\) 即 \(p - L + r\) 右边。

综上，我们需要对 \(f\) 进行 \([q + L - l, q + r - 1]\) 区间加 \(1\)，对 \(g\) 进行 \([p - l + 1, p - L + r]\) 区间加 \(1\)。差分维护即可。

求任意两个前缀的 LCS 或任意两个后缀的 LCP 可借助 SA 实现。

时间复杂度线性对数，包括建出 SA，建出 \(ht\) 的 ST 表以及枚举 \(L\) 的调和级数。代码。

从这道题开始，设置关键点变成了经典套路。

*SP687 REPEATS - Repeats

借用优秀的拆分的套路，直接枚举循环节长度 \(L\)，每相邻 \(L\) 个位置放置一个关键点。容易发现，若某个长度为 \(L\) 的子串连续出现 \(k\) 次，则它恰好跨过 \(k\) 个关键点。

Sol 1：显然答案满足可二分性。二分 \(k\)，考虑所有连续 \(k\) 个关键点 \(p, p + L, \cdots, p + (k - 1)L\)，若这些位置对应的所有后缀的 LCP（长度 \(tor\)）加上它们对应的所有前缀的 LCS（长度 \(tol\)）减去同时覆盖的关键点后覆盖的长度不小于 \(L\)，即 \(tor + tol - 1 \geq L\)，说明出现 \((k, L)\) - repeat。从小到大扫过所有连续的 \(k\) 个关键点，用单调队列维护当前窗口内关键点排名的最大值和最小值方便求 LCP & LCS。因为关键点总数为调和级数的 \(\mathcal{O}(n\ln n)\)，所以时间复杂度 \(\mathcal{O}(n\log ^ 2 n)\)。

Sol 2：Sol 1 太不优美了。\(L\) 固定时，称关键点区间 \([l, r]\) 表示关键点为 \(p_l, p_{l + 1}, \cdots, p_r(p_i = p_{i - 1} + L)\) 是优秀的，当且仅当它对应的 \(tor + tol - 1\) 不大于 \(L\)，出现 \((r - l + 1, L)\) - repeat。显然若 \([l, r]\) 优秀则其任何子区间优秀，推得 \(r\) 增加时最左合法左端点单调不降，满足 two-pointers 的条件。双指针替代二分，时间复杂度 \(\mathcal{O}(n\log n)\)。

Sol 3：Sol 2 仍不够优美。根据 border 论最经典结论，\(s\) 有长 \(L\) 的 period 当且仅当 \(s\) 有长 \(n - L\) 的 border，即 \(s[1, n - L] = s[L + 1, n]\)。考虑相邻关键点 \(p\) 和 \(q = p + L\)，求出 \(tor = |\mathrm{lcp}(suf_p, suf_q)|\) 和 \(tol = |lcs(pre_p, pre_q)|\)，说明 \(suf_{p - tol + 1}\) 和 \(suf_{q - tol + 1}\) 有长为 \(tol + tor - 1\) 的 LCP。为使得覆盖 \(p, q\) 的 \((k, L)\) - repeat 最长，它会从 \(p - tol + 1\) 开始，满足有 border \(s[p - tol + 1, p + tor - 1] = s[q - tol + 1, q + tor - 1]\)。容易发现对应出现次数 \(k\) 等于 \(\frac {(q + tor - 1) - (p - tol + 1) + 1} L\) 即 \(\frac {tol + tor - 1} L\) 下取整后加 \(1\)。所有相邻两个 \(p, q\) 的该式最大值即为所求。时间复杂度仍为线性对数，但代码好写很多。代码。

CF1608G Alphabetic Tree

毒瘤细节码农题。

首先，对于一次询问 \(Q(u, v, l, r)\)，由于信息具有可减性，所以转化为 \(Q(u, v, 1, r) - Q(u, v, 1, l - 1)\)，记为 \(Q(u, v, r) - Q(u, v, l - 1)\)。相当于做一个扫描线。

对于后缀数组，对特定 \(t\) 求解 \(t\) 在文本串 \(s\) 中出现次数的方法是二分找到第一个 \(\geq t\) 的后缀排名 \(L\)，以及最后一个 \(\leq t\) 的后缀排名 \(R\)。任何排名在 \([L, R]\) 之间的后缀均以 \(t\) 为前缀，代表 \(t\) 在 \(s\) 中的一次出现。

对于本题也一样。我们先对 \(s_i\) 进行后缀排序，设当前扫描线到位置 \(p\)，则管用的只有 \(s_{1\sim p}\) 的后缀。对于一次询问 \(Q(u, v, p)\)，我们只需要对 \(u\to v\) 形成的字符串 \(t(u\to v)\) 进行上述操作即可。

具体地，二分排名 \(m\)，问题转化为比较 \(t(u\to v)\) 和排名为 \(m\) 的后缀 \(s\) 的大小关系。一般的比较方法是二分 LCP 然后判下一个字符的大小关系。对于本题，如果再二分 LCP \(len\)，那么需要求出 \(s[1, len]\) 的哈希值，以及 \(u\to v\) 长度为 \(len\) 的前缀的哈希值，后者需要树上倍增求解，时间复杂度 \(\mathcal{O}(q\log ^ 3n)\)，不可接受。但我们注意到倍增的过程本质上也是一种二分，因此将倍增和二分结合起来即可做到 \(\mathcal{O}(q\log ^ 2 n)\)。

求得 \(t(u\to v)\) 对应的排名区间 \([L, R]\) 后，只需求出当中有多少个管用的后缀，扫描线时 BIT 维护即可。代码。以下是一些注意点：

• 哈希值的每一位不能直接减去 'a'，否则 aab 和 ab 会被视作相等。
• 哈希 base 应大于多串 SA 插入分隔符的最大数值。
• 二分 \(L\) 的下界为 \(1\)，上界为 SA 总长加 \(1\)，\(R\) 的上下界要减去 \(1\)。
• 注意分清排名和下标。

*GYM102803E Everybody Lost Somebody

一道考察对 SA 的 \(sa\)，\(rk\) 和 \(ht\) 数组综合理解的题目。

对于 \(ht_i\neq -1\)，枚举 \(j\in [0, ht_i)\)，则 \(s[sa_i + j] = s[sa_{i + 1} + j]\)，且 \(s[sa_i + ht_i] < s[sa_{i + 1} + ht_i]\)。若 \(ht_i\) 不存在等于 \(-1\) 的情况，则直接并查集合并相同的位置，然后对于小于的限制连边跑拓扑排序即可。

接下来考虑 \(ht_i = -1\)。此时对于 \(sa_i\) 和 \(sa_{i + 1}\) 的 LCP 没有限制，唯一的限制就是 \(su_{sa_i} < su_{sa_{i + 1}}\)。这对 \(s[sa_i]\) 和 \(s[sa_{i + 1}]\) 提出了一些要求。

使用倍增桶排求解 SA 的思想，我们知道 \(su(sa_i)\) 和 \(su(sa_{i + 1})\) 的大小关系取决于 \(s[sa_i]\) 和 \(s[sa_{i + 1}]\) 以及 \(su(sa_i + 1)\) 和 \(su(sa_{i + 1} + 1)\)。当 \(rk(sa_i + 1) < rk(sa_{i + 1} + 1)\) 时，\(s[sa_i]\) 只需不大于 \(s[sa_{i + 1}]\)，否则 \(s[sa_i]\) 需要小于 \(s[sa_{i + 1}]\)。

对于所有不大于和小于的限制，通过赋边权 \(0\) 或 \(1\) 结合拓扑排序求解。时间复杂度 \(\mathcal{O}(n ^ 2)\)。代码。

接下来考虑加强版 \(n \leq 10 ^ 6\)。复杂度瓶颈在于并查集合并相等字符的限制，但显然我们有很多合并都是浪费的，有用的合并最多只有 \(n - 1\) 次。

注意到 \(s[i] = s[j]\) 意味着对于所有 \(p\in [rk_i, rk_j]\)（不妨设 \(rk_i < rk_j\)）均有 \(s[i] = s[sa_p]\)。这相当于为 \(rk_i\sim rk_j - 1\) 打上标记。位置 \(p\) 被打上标记表示 \(s[sa_p] = s[sa_{p + 1}]\)。\(n ^ 2\) 次区间修改操作，通过差分转化为 \(n ^ 2\) 次单点修改。

注意到对于一个 \(sa_i\)，所有单点加 \(1\) 的 \(rk(sa_i + j)\) 关于下标 \(sa_i + j\)（注意不是关于排名 \(rk(sa_i + j)\)）形成一段区间 \([sa_i, sa_i + ht_i)\)。这相当于对给 \(rk_p\) 打标记的差分序列进行 关于原序列下标 \(p\) 的区间修改，二次差分即可。

容易将并查集的复杂度去掉，时间复杂度 \(\mathcal{O}(n)\)。代码。

*CF1043G Speckled Band

易知答案不超过 \(4\)，因为若出现两个相等的字符，可以用 \(bacad\) 的方式分割字符串。因此我们尝试对每种情况分别讨论一下，令 \(t = s_{l\sim r}\)。

显然，答案为 \(-1\) 当且仅当 \(t\) 不包含相同字符。

若答案为 \(1\)，则 \(t\) 有整除它长度的周期，等价于 \(t\) 有长为 \(|t| - d\) 的 border。枚举因数判一下即可，用哈希或各种后缀字符串结构均可。

若答案是 \(2\)，则 \(t\) 必然形如 \(aba\)，\(aab\) 或 \(abb\)：若 \(t\) 存在 border 则存在不相交 border，直接把 border 割来即可；当 \(t\) 不存在 border 时，它的两端不同，形如 \(a * b\)。若形如 \(ab * ab\) 则存在 border，矛盾，因此形如 \(aa * b\) 或 \(a * bb\)，可转化成 \(aab\) 或 \(abb\)。

\(aba\) 这种情况有些棘手，我们放在最后讨论。\(aab\) 和 \(baa\) 本质上是一样的，可以通过 “优秀的拆分” 枚举长度 + 设置关键点的套路求出所有形如 \(aa\) 的字符串的出现位置，形成共 \(n\ln n\) 个区间。维护 \(lft_i\) 表示从 \(i\) 开始最短的形如 \(aa\) 的字符串长度，\(rt_i\) 则表示以 \(i\) 结尾的。每个区间相当于为 \(lft\) 和 \(rt\) 区间 \(\rm checkmin\)。从小到大枚举长度，并查集维护。

若答案为 \(3\)，首先两端必然不等，形如 \(a * b\)。若 \(*\) 中出现 \(a\) 或 \(b\)，那么直接 \(abcb\) 或者 \(acab\) 即可。只需判 \(s_l\) 和 \(s_r\) 是否在 \(s_{l + 1\sim r - 1}\) 当中出现过。否则根据出现次数 \(\geq 2\) 的限制，只能为 \(ac \cdots cb\)，简化为 \(accb\)。因为维护了 \(lft\) 这个信息，直接判断是否有 \(\min_{i = l} ^ r (i + lft_i - 1) \leq r\) 即可。

若上述条件均不符合，则答案为 \(4\)。

最后解决一个遗留问题：求一个子串是否存在 border。当然这可以通过 “border 的四种求法” 的 border 论或 SAM + 树剖解决，但因为只需判断 border 的存在性，所以存在一个优美且巧妙的根号做法。

若 border 相交，则必然形成长度更短的 border。因此我们不妨 钦定 border 不交，得到根号分治做法：若 border 长度小于 \(\sqrt n\)，直接枚举。若 border 长度不小于 \(\sqrt n\)，那么它在整个字符串中的出现次数不超过 \(\sqrt n\)，可在后缀数组上枚举 \(l\) 后缀的排名的半径为 \(\sqrt n\) 的排名邻域判断。

时间复杂度 \(\mathcal{O}(n\log n + q\sqrt n)\)，但是很优美。代码。

*牛客多校 2022#6L Striking String Problem

给定字符串 \(S, T\)，正整数 \(k\) 和 \(2k\) 个整数 \(l_i, r_i\)，令 \(U = S[l_1, r_1] + \cdots + S[l_k, r_k]\)。\(q\) 次询问给定 \(x, y\)，求 \(T\) 在 \(U[x, y]\) 中的出现次数。

\(1 \leq l_i\leq r_i \leq |S| \leq 10 ^ 6\)，\(1\leq k, q \leq 5 \times 10 ^ 5\)，\(1\leq |T| \leq 5\times 10 ^ 5\)，\(1\leq x_i \leq y_i \leq |U|\)，时间限制 8s，空间限制 1G。

模拟赛题加强出到牛客多校了，比赛链接。

定义 \(S\) 与 \(T\) 的最长公共后缀前缀为 \(X\)，其中 \(X\) 最长且 \(S[|S| - |X| + 1, |S|] = T[1, |X|]\)，注意顺序。

设 \(L_i = r_i - l_i + 1\)，\(Q_i = S[l_i, r_i]\)。

将询问差分，变成 \(T\) 在 \(U[1, r]\) 中的出现次数减去 \(T\) 在 \(U[1, l + T - 2]\) 中的出现次数。因此，简化询问形式为求 \(T\) 在 \(U[1, P]\) 中的出现次数，用数 \(P\) 描述。

单模式串整体匹配通常使用 KMP，对 \(T\) 求 KMP 数组 \(nxt\)。令 \(U_i = Q_1 + \cdots + Q_i\)，考虑 \(U\) 不断匹配 \(T\) 的过程，不妨设 \(U_{i - 1}\) 与 \(T\) 的最长公共后缀前缀长度为 \(M\)，即 \(U_i[|U_i| - M + 1, |U_i|] = T[1, M]\)。

朴素算法为暴力匹配 \(S[l_i, r_i]\) 并更新 \(M\)，时间复杂度 \(\mathcal{O}(|U|)\)，无法通过。

注意到在处理 \(S[l_i, r_i]\) 时只需知道 \(M\) 的值而不关心 \(U_{i - 1}\) 具体长什么样，因此，实时维护 \(M\) 即可独立各个 \(S\) 的子串，对它们分别处理。

将问题分成两部分求解，一为计数，二为维护 \(M\)。

• 维护 \(M\)：

问题相当于求 \(T[1, M] + Q_i\) 与 \(T\) 的最长公共后缀前缀长度 \(M'\)。

两种情况，\(M' > L_i\) 或 \(M' \leq L_i\)。

对于后者，只需预处理 \(p_i\) 表示 \(S[1, i]\) 与 \(T\) 的最长公共后缀前缀长度，\(p_i\) 可用 \(T\) 对 \(S\) 做 KMP 匹配求得。注意要在 KMP 树（也称失配树，border 树）上倍增到第一个 \(\leq L_i\) 的节点。

对于前者，令 \(D = M' - L_i\)，则 \(T[M - D + 1, M] + Q_i = T[1, M']\)。考虑其充要条件：

• 第一，\(T[M - D + 1, M] = T[1, D]\)，即 \(T[1, D]\) 为 \(T[1, M]\) 的 border。
• 第二，\(Q_i = T[D + 1, M']\)，即 \(S[l_i, |S|]\) 与 \(T[D + 1, |T|]\) 的最长公共前缀不小于 \(L_i\)。

考虑条件 1，建出 \(T\) 的 border 树，则合法的 \(D\) 限制为 \(M\) 及其祖先。

考虑条件 2，建出 \(S + T\) 的后缀数组，使得 \(|\mathrm{lcp}(S[l_i, |S|], T[D + 1, |T|])| \geq L_i\) 的排名为一段区间 \(rkl_i, rkr_i\)，可预处理 \(ht\) 倍增数组后对每个 \(Q_i\) 二分求得。

容易发现，只需求得 \(M\) 数值最大的祖先 \(D\)，使得 \(T[D, |T|]\) 在后缀数组的排名在区间 \([rkl_i, rkr_i]\) 中。

树上可持久化线段树，\(B_M\) 维护 \(M\) 及其所有祖先 \(A\) 对应后缀 \(T[A, |T|]\) 的排名。下标表示排名，区间维护排名落在该区间的 \(T[A, |T|]\) 的 \(A\) 的最大值，求 \(D\) 即对 \(B_M\) 查询区间 \([rkl_i, rkr_i]\) 最值。

• 计数：

为方便计数，限制 \(M < |T|\)。即若上一部分求得 \(M' = |T|\)，则令 \(M\gets nxt_{M'}\)。

处理 \(Q_i\) 时，我们回答落在 \((|U_{i - 1}|, |U_i|]\) 的询问。用变量 \(alr\) 表示 \(T\) 在 \(U_{i - 1}\) 中的出现次数，并实时维护 \(alr\)。

仔细思考后容易发现一次询问相当于求 \(T\) 在 \(T[1, M] + S[l_i, l_i + P - 1]\) 中的出现次数，加上 \(alr\)，用 \(query(M, l_i, P)\) 描述。

同样，分成两种情况讨论，\(T\) 是否完全包含于 \(S[l_i, l_i + P - 1]\)。

若完全包含，首先 \(P\) 不小于 \(T\)，考虑预处理 \(p_i\) 的过程中一并求出 \(T\) 在 \(S\) 的所有出现位置 \(E\)（结尾对应位置，即 \(T = S[e - |T| + 1, e](e\in E)\)）。问题即求 \(E\) 中落在 \([l_i + T - 1, l_i + P - 1]\) 的数的个数。静态区间和，前缀和即可。

若不完全包含，设出现位置在 \(S\) 中对应 \(X\)，即 \(T = T[M - (|T| - (X - l_i + 1) + 1) + 1, M] + S[l_i, X]\)，其中 \(|T| - (X - l_i + 1) + 1\) 即 \(T\) 这次出现在 \(T[1, M]\) 的覆盖长度，令 \(D\) 为该值，则 \(T[1, D] = T[M - D + 1, M]\)。

因此，类似维护 \(M\) 的情况，对 \(M\) 的每个 \(D\) 检查是否对应一次出现。考虑其充要条件：

• \(D + P \geq |T|\)。
• \(|\mathrm{lcp}(T[D + 1, |T|], S[l_i, |S|])| \geq T - D\)。

不同于维护 \(M\)，这次不等式右侧的 \(T - D\) 仅与 \(T\) 有关，但合法的后缀在后缀数组上仍为一段区间。同样，树上可持久化线段树 \(C_M\) 维护，注意修改形式为区间加法，需标记永久化。

查询时，树上倍增找到最深的使得 \(A + P < T\) 的 \(A\)（若不存在可视为 \(0\)），在 \(C_M - C_A\) 上查询 \(S[l_i, |S|]\) 排名处的取值即可。

更新 \(alr\) 只需将其加上 \(query(M, l_i, L_i)\)。

减小空间常数的方法：问题转化为给定一棵树，每个点有区间 \([c_i, d_i]\)，查询某个点到根的路径上对应区间包含 \(e_i\) 的点的数量，可离线扫描 + BIT。

综上，设 \(n = |S|\)，\(m = |T|\)，则时间复杂度 \(\mathcal{O}((k + q + n + m)\log (n + m))\)，空间复杂度 \(\mathcal{O}((n + m)\log (n + m))\)。

*CF917E Upside Down

以 \(1\) 为根，将问题分成直链和跨过 \(d = \mathrm{lca}(u, v)\) 分别求解。设 \(\mathrm{str}(u, v)\) 表示 \(u\to v\) 的路径所表示字符串。

对于直链，相当于 \(s_k\) 在 \(str(d, v)\) 中的出现次数加上 \(s_k ^ R\) 在 \(str(d, u)\) 中的出现次数。差分转化为从根到某个点的路径上 \(s_k\) 或 \(s_k ^ R\) 的出现次数。分别建出正串和反串的 AC 自动机，则问题形如从根到某点在 AC 自动机上形成的路径上满足以 \(s_k\) 作为 fail 树上的祖先的状态。dfs 时用树状数组维护单点修改，区间查询。

对于跨过 LCA，比较困难。考虑求出 \(str(u, d)\) 最长 真后缀 \(P\) 使得它为 \(s_k\) 的前缀，\(str(d, v)\) 最长 真前缀 \(Q\) 使得它为 \(s_k\) 的后缀，则所有 \(P\) 的 border 均可与 \(str(u, d)\) 对应长度的后缀匹配，\(Q\) 的 border 均可与 \(str(d, v)\) 对应长度的前缀匹配。因此，若 \(x\) 为 \(P\) 的 border 长且 \(|s_k| - x\) 为 \(Q\) 的 border 长，则产生一次贡献。建出 \(s_k\) 和 \(s_k ^ R\) 的失配树 \(F\) 和 \(F ^ R\)，则问题形如给定 \(p, q\) 求满足 \(x\) 在 \(F\) 上的 \(p\) 到根的路径上且 \(|s_k| - x\) 在 \(F ^ R\) 上的 \(q\) 到根的路径上的 \(x\) 的数量。树上二维数点，对 \(F\) 离线 dfs，每遍历到一个点 \(x\) 就将 \(|s_k| - x\) 加入当前集合 \(S\)，并回答 \(p = x\) 的询问 \((p, q)\)，即查询 \(S\) 中 \(q\) 的祖先的数量。时间戳拍平 \(F ^ R\) 之后区间修改，单点查询。离开时再将 \(|s_k| - x\) 删去。

问题转化为求 \(P\) 和 \(Q\) 的长度。对于形如给定 \(s, t\)，求 \(t\) 的最长后缀使得它是 \(s\) 的前缀的问题，有两个经典解法，Z 算法和后缀数组。Z 算法灵活性较差，本题一个字符串通过树上路径确定，不可行，因此考虑后缀数组。对 \(t\) 建出后缀数组，二分得到 \(s\) 在后缀数组中的位置，求出使得 \(\mathrm{lcp}(s, t[p, |t|])\) 最大的 \(p\) 以及对应 LCP \(L\)，则 \(t[p, |t|]\) 最长的长度 \(\leq L\) 的 border 即为所求。

对于本题可以如法炮制。求 \(P\) 时，求 \(str(d, u)\) 最长真前缀使得它为 \(s_k ^ R\) 的后缀。求 \(Q\) 时，求 \(str(d, v)\) 最长真前缀使得它为 \(s_k\) 的后缀。在后缀数组中定位时需要比较链和某个后缀的大小，二分 LCP 并比较下一个字符。但二分 LCP 之后还要求树上 \(k\) 级祖先，写长剖太麻烦了，将倍增和二分结合在一起即可做到单次比较 \(\mathcal{O}(\log n)\)。

时间复杂度 \(\mathcal{O}(q\log ^ 2 n)\)。代码。

CHANGE LOG

• 2021.12.12：新增 KMP 算法与 Z 算法。
• 2021.12.13：修改部分笔误。
• 2021.12.23：新增前言。
• 2021.12.24：新增 SA 应用部分。
• 2022.1.10：新增几个 SA 应用与例题。
• 2022.6.10：重构文章，修改表述。
• 2023.1.23：修改表述。
• 2023.2.3：移除 KMP 和 Border 论。
• 2023.4.8：更新后缀排序的介绍。

参考资料

定义部分：

• 字符串简介 - OI Wiki。

第一章：

• Manacher - OI Wiki。

第二章：

• Z 函数（扩展 KMP）- OI Wiki。

第三章：

• 后缀数组简介 - OI Wiki。

标签：子串,后缀,基础,ht,字符串,sa,rk,回文
From： https://www.cnblogs.com/alex-wei/p/Basic_String_Theory.html