Runs 小记

来一点不严谨、不详细的备忘性质的速通学习笔记。不放证明了，证明大家可以去洛谷题解区看我稍微看了一眼，然后忘了。

首先什么是 Runs？我的理解是它就是一个压缩了所有本质不同的平方串的结构。对于一个字符串 \(S\)，定义它的一个 Runs 是满足如下条件的三元组 \((l,r,p)\)：

• \(S[l,r]\) 的最小周期为 \(p\)。

• \(2p \le r - l + 1\)。

• 该结构不能继续向左向右扩展。即 \(S_{l-1}\ne S_{l + p - 1},S_{r + 1}\ne S_{r - p + 1}\)。（这里认为边界填充了一个不在字符集中的极小值）

Runs 和平方串之间的关系：显然每个 Runs 的长度为 \(2p\) 的倍数的子串一定是一个平方串，反过来也很容易得到任何一个平方串一定至少位于一个 Runs 中，因为一个平方串就是一个未经扩展的 Runs。

一个更强的性质是，一个平方串可以用上述方式唯一被一个 Runs 统计到。证明的大致思想大概是你考虑一个互相包含的 Runs，大的 Runs 的最小周期必须严格大于小的 Runs 的最小周期。而我们可以证明，对于一个 Runs 的所有长度至少为 \(2p\) 的子串，其最小周期一定为 \(p\)。所以一个最小周期为 \(p\) 的平方串（长度 \(2kp\)），其只会被最小周期恰好为 \(p\) 的 Runs 统计恰好一次。

如何求出 Runs？一个非常简单的想法是考虑在《优秀的拆分》中运用到的调和级数分块。我们枚举当前 Runs 的周期 \(p\)，然后每隔 \(p\) 个点扔一个关键点。接下来枚举相邻的两个关键点，钦定每一个 Runs 在它的区间中前两个关键点统计到。那么从这两个关键点往前做 \(\operatorname{lcs}\) 匹配，往后做 \(\operatorname{lcp}\) 匹配，如果总匹配长度 \(\ge 2p\) 且往前做的 \(\operatorname{lcs}\) 没有包含上一个关键点，就找到了一个不一定满足第一个条件的准 Runs。

对于一个 Runs \((l,r,p)\)，其可能在 \(2p,3p\dots\) 处多次统计，那么对于所有你求出来的准 Runs 中，\((l,r)\) 相同的取 \(p\) 最小的哪些就是真正的 Runs 了，复杂度可以用计数排序去重做到严格 \(O(n\log n)\)。

一般来说，让你写平方串的题目，写调和级数分块已经足够解决问题了。

既然已经有了调和级数分块，我们为什么还需要 Runs 这个结构呢？一大原因是，对于刻画所有平方串组成的集合的性质的题目，我们想要更低的复杂度。

Runs 的一个关键性质是，对于一个串，至多有 \(2n\) 种 Runs。我们可以通过一种构造 Runs 算法来说明这个性质：

我们考虑减少调和级数分块做法中，我们需要枚举的关键点对数量。对于一个 Runs，其所有长度为 \(p\) 的子串是同一个串的不同循环移位，我们找出其中的最小表示法 \(S[k,k+p-1]\)。

可以证明的一个关键性质：\(S[k,k+p-1]\) 不存在任何 Border。

这带来两个非常好的推论：一个是 \(S[k,k+p-1]\) 是一个 Lyndon 串；另一个是，如果钦定 \(k\le l+p-1\)，该最小表示法的位置是唯一的，后文的算法钦定在此最小表示法的位置处统计该 Runs。

那么这意味着，字符串以 \(k\) 开始的后缀 \(S[k,n]\) 严格小于所有 \(t\in [k+1,k+p-1]\) 的后缀 \(S[t,n]\)。

我们先求出每个后缀在后缀数组中的排名 \(rk\)，然后对于每一个 \(i\)，找到其之后第一个在 \(rk_i>rk_j\) 位置 \(j\)。将 \(i,j\) 作为关键点对扩展出一个 Runs。（这里为了不重复统计同一个 Runs，同样可以钦定我们统计的一定是该 Runs 中出现的第一个循环最小表示法；当然也可以事后去重）。

这样扩展出的 Runs 一定满足性质：\(rk_k > rk_{k+p}\)，通过 Runs 的周期性质可以发现这个条件等价于 \(S_{r-p+1}>S_{r+1}\)。

那么那种 \(S_{r-p+1}<S_{r+1}\) 的 Runs 该怎么统计呢？对于上述的所有讨论，我们人为逆转字符集的大小关系（包括字符串末尾填充的空字符，从极小值逆转成极大值），相当于 reverse 了一下后缀数组，然后按照刚才的方法再次找出 \(O(n)\) 对关键点对扩展。

由于上述讨论，我们就证明了 Runs 的个数不超过 \(2n\)，且给出了一种更加清新的 Runs 构造方法。如果使用 SA-IS + \(O(n)-O(1)\) RMQ 算法实现以上过程，可以把复杂度降低到 \(O(n)\)。

最后讲一个某道互测题里用到了的性质，对于所有 Runs，\(\lfloor \frac{r-l+1}{p}\rfloor\) 之和也是线性级别的。这是因为我们之前在统计 Runs 的时候，我们是把它贡献到前 \(p\) 个长度为 \(p\) 的串中最小的那一个串统计的。那么，实际上对于该 Runs 的每 \(p\) 个串，都可以把它挂到一个你求出来的关键点对上去。

#include <algorithm>
#include <cassert>
#include <cstdio>
#include <cstring>
using namespace std;
int read() {
    char c = getchar();
    int x = 0;
    while (c < 48 or c > 57)
        c = getchar();
    do
        x = (x * 10) + (c ^ 48), c = getchar();
    while (c >= 48 and c <= 57);
    return x;
}
const int N = 1000003;
const int Lg = 20;
int n, q;
struct LCP {
    char s[N];
    int buc[N], rk[N], sa[N], od[N], id[N], ht[Lg][N], w, p;
    bool eq(int x, int y) {
        return od[x] == od[y] && od[x + w] == od[y + w];
    }
    void getSA(int m) {
        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 i = 1; i <= m; ++i)
            buc[i] = 0;
        w = 1;
        p = 0;
        while (true) {
            for (int i = n; i > n - w; --i)
                id[++p] = i;
            for (int i = 1; i <= n; ++i)
                if (sa[i] > w)
                    id[++p] = sa[i] - w;
            for (int i = 1; i <= n; ++i)
                ++buc[od[i] = 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 <= m; ++i)
                buc[i] = 0;
            rk[sa[1]] = p = 1;
            for (int i = 2; i <= n; ++i) {
                if (!eq(sa[i], sa[i - 1]))
                    ++p;
                rk[sa[i]] = p;
            }
            if (p == n)
                break;
            w <<= 1, m = p, p = 0;
        }
    }
    void getLCP() {
        s[n + 1] = '!';
        for (int i = 1, k = 0; i <= n; ++i) {
            if (k)
                --k;
            if (rk[i] == 1)
                continue;
            while (s[i + k] == s[sa[rk[i] - 1] + k])
                ++k;
            ht[0][rk[i]] = k;
        }
        for (int t = 1; t < Lg; ++t)
            for (int i = 2; i + (1 << t) - 1 <= n; ++i)
                ht[t][i] = min(ht[t - 1][i], ht[t - 1][i + (1 << (t - 1))]);
    }
    int qry(int x, int y) {
        if (x == y)
            return n - x + 1;
        x = rk[x], y = rk[y];
        if (x > y)
            swap(x, y);
        int k = __lg(y - x);
        return min(ht[k][x + 1], ht[k][y - (1 << k) + 1]);
    }
} A, B;
char s[N];
int wl[N << 1], wr[N << 1], wp[N << 1], num;
void expand(int x, int y) {
    if (s[x] != s[y])
        return;
    int len = y - x;
    int lA = A.qry(x, y);
    int lB = B.qry(n - x + 1, n - y + 1);
    if (lB <= len and lA + lB > len) {
        ++num;
        wl[num] = x - lB + 1;
        wr[num] = y + lA - 1;
        wp[num] = len;
    }
}
int stk[N], tp;
int p[N << 1], pp[N << 1], loc[N];
void sort_by(int *arr) {
    for (int i = 1; i <= num; ++i)
        ++loc[arr[i]];
    for (int i = 1; i <= n; ++i)
        loc[i] += loc[i - 1];
    for (int i = num; i; --i)
        pp[loc[arr[p[i]]]--] = p[i];
    for (int i = 1; i <= num; ++i)
        p[i] = pp[i];
    for (int i = 1; i <= n; ++i)
        loc[i] = 0;
}
int main() {
    scanf("%s", s + 1);
    n = strlen(s + 1);
    for (int i = 1; i <= n; ++i)
        A.s[i] = B.s[n - i + 1] = s[i];
    A.getSA(123), A.getLCP();
    B.getSA(123), B.getLCP();
    tp = 0;
    for (int i = n; i; --i) {
        while (tp and A.rk[stk[tp]] > A.rk[i])
            --tp;
        if (tp)
            expand(i, stk[tp]);
        stk[++tp] = i;
    }
    tp = 0;
    for (int i = n; i; --i) {
        while (tp and A.rk[stk[tp]] < A.rk[i])
            --tp;
        if (tp)
            expand(i, stk[tp]);
        stk[++tp] = i;
    }
    for (int i = 1; i <= num; ++i)
        p[i] = i;
    sort_by(wp), sort_by(wr), sort_by(wl);
    printf("%d\n", num);
    for (int i = 1; i <= num; ++i)
        printf("%d %d %d\n", wl[p[i]], wr[p[i]], wp[p[i]]);
    return 0;
}