洛谷P1117 [NOI2016]优秀的拆分（巧妙的计数方法）

题目

[NOI2016]优秀的拆分

分析

统计以$S_i$开头的形如$\text{AA}$的子串的数量，存入$L[i]$；统计以$S_i$结尾的形如$\text{AA}$的子串，存入$R[i]$。于是把可以把它们拼起来，答案就是$\sum _{i=2}^n(L[i]\times R[i-1])$。
$L$与$R$数组的处理，暴力枚举+哈希判断相等是$O(n^2)$的，考虑优化这个东西。

我们枚举$\text{A}$的长度$l$，那么一个$\text{A}$在$S$中会经过且仅经过一个$S_{k\cdot l}$，如图所示，蓝点是$S_{k\cdot l}$，可见任何一个长度为$l$的子串必然经过一个蓝点。

那么我们把这个串看成左右两端，即以$S_{k\cdot l}$开始的后缀（下图中橙色示意的范围）和以$S_{k\cdot l}$开始的前缀（下图中绿色示意的范围），这两个前后缀在$S_{k\cdot l}$处重合。

不妨假设这个串是某个$\text{AA}$的子串的前一个$\text{A}$，那么它后面紧接着一个跟它一模一样的：

即橙色（两个后缀）和绿色（两个前缀）分别相等。
发现了，我们只需要找到以$S_{k\cdot l}$与$S_{(k+1)\cdot l}$结尾的最长公共后缀（LCS），和以$S_{k\cdot l}$与$S_{(k+1)\cdot l}$开头的最长公共前缀（LCP），这两个二分+哈希$O(n\log n)$即可找到。

找到了过后，看下图（下图的$l=7$，且只是截取了$S$中的一部分），假设橙色标记的是LCS，绿色标记的是LCP，那么红色标记三对子串都是形如$\text{AA}$的：

这个时候我们就左边的三个端点（灰色）的$R[i]$全部加一，右边的三个端点（灰色）的$L[i]$全部加一即可，只有区间加法，差分一下即可 （当然线段树也可以） 。

给不明白差分的小伙伴；
令$L^{\prime }[i]=L[i]-L[i-1]$，那么我们对$L^{\prime }[i]$进行操作，最后可以通过$L[i]=\sum _{j=1}^i{L}^{\prime }[j]$，来还原$L[i]$。
发现$L[i]$其实是$L^{\prime }[i]$的前缀和数组，那么$L[i]$的区间加法（$[l,r]$上加$d$），在$L^{\prime }[i]$上只用改两个点：$L^{\prime }[l]+=d$，$L^{\prime }[r+1]-=d$，这样一来，想想算前缀和的过程，$[l,r]$这一段全部都多了$d$。

总时间复杂度$O\left(\left(\frac{n}{1}+\frac{n}{2}+\cdots +\frac{n}{n}\right)\log n\right)=O(n{\log }^{2}n)$。（用SAM/SA可以少个log？）

代码

#include <algorithm>
#include <cstdio>
#include <cstring>
#include <queue>

int Read() {
    int x = 0; bool f = false; char c = getchar();
    while (c < '0' || c > '9')
        f |= c =='-', c = getchar();
    while (c >= '0' && c <= '9')
        x = x * 10 + (c ^ 48), c = getchar();
    return f ? -x : x;
}

typedef long long LL;

const int MAXN = 30000;
const int PRIME = 233;
const int MOD = 1000000009;

int N;
char S[MAXN + 5];
int L[MAXN + 5], R[MAXN + 5];

int Hash[MAXN + 5], Pow[MAXN + 5];

int Key(int lft, int rgt) {
    return (Hash[rgt] - (LL)Hash[lft - 1] * Pow[rgt - lft + 1] % MOD + MOD) % MOD;
}

int GetLCS(int i, int j) {
    int lft = 0, rgt = std::min(j - i, i) + 1; // 注意上界不要超了，否则会访问到不该访问的地方
    while (lft + 1 < rgt) {
        int mid = (lft + rgt) >> 1;
        if (Key(i - mid + 1, i) == Key(j - mid + 1, j))
            lft = mid;
        else
            rgt = mid;
    }
    return lft;
}

int GetLCP(int i, int j) {
    int lft = 0, rgt = std::min(j - i, N - j + 1) + 1; // 这里也是
    while (lft + 1 < rgt) {
        int mid = (lft + rgt) >> 1;
        if (Key(i, i + mid - 1) == Key(j, j + mid - 1))
            lft = mid;
        else
            rgt = mid;
    }
    return lft;
}

int main() {
    Pow[0] = 1;
    int T = Read();
    while (T--) {
        scanf("%s", S + 1);
        N = strlen(S + 1);
        for (int i = 1; i <= N; i++) {
            L[i] = R[i] = 0;
            Pow[i] = (LL)Pow[i - 1] * PRIME % MOD;
            Hash[i] = ((LL)Hash[i - 1] * PRIME + (S[i] - 'a')) % MOD;
        }
        for (int len = 1; 2 * len <= N; len++) {
            for (int i = 1; i + len <= N; i += len) {
                int lcs = GetLCS(i, i + len), lcp = GetLCP(i, i + len);
                if (lcs + lcp - 1 >= len) {
                    L[i - lcs + 1]++, L[i + lcp - len + 1]--;
                    R[i - lcs + 2 * len]++, R[i + lcp + len]--; // 这四个点自己参照图算一下就能找到
                }
            }
        }
        for (int i = 1; i <= N; i++)
            L[i] += L[i - 1], R[i] += R[i - 1]; // 由差分数组还原
        long long Ans = 0;
        for (int i = 2; i <= N; i++)
            Ans += (long long)L[i] * R[i - 1];
        printf("%lld\n", Ans);
    }
}