【NOI 2016】优秀的拆分

Problem

Description

如果一个字符串可以被拆分为 \(AABB\) 的形式，其中 \(A\) 和 \(B\) 是任意非空字符串，则我们称该字符串的这种拆分是优秀的。

例如，对于字符串 aabaabaa，如果令 \(A = \mathrm{aab}\)，\(B = \mathrm{a}\)，我们就找到了这个字符串拆分成 \(AABB\) 的一种方式。

一个字符串可能没有优秀的拆分，也可能存在不止一种优秀的拆分。比如我们令 \(A=\mathrm{a}\)，\(B=\mathrm{baa}\)，也可以用 \(AABB\) 表示出上述字符串；但是，字符串 abaabaa 就没有优秀的拆分。

现在给出一个长度为 \(n\) 的字符串 \(S\)，我们需要求出，在它所有子串的所有拆分方式中，优秀拆分的总个数。这里的子串是指字符串中连续的一段。

以下事项需要注意：

1. 出现在不同位置的相同子串，我们认为是不同的子串，它们的优秀拆分均会被记入答案。
2. 在一个拆分中，允许出现 \(A=B\)。例如 cccc 存在拆分 \(A=B=\mathtt{c}\)。
3. 字符串本身也是它的一个子串。

Input Format

每个输入文件包含多组数据。输入文件的第一行只有一个整数 \(T\)，表示数据的组数。保证 \(1 \le T \le 10\)。

接下来 \(T\) 行，每行包含一个仅由英文小写字母构成的字符串 \(S\)，意义如题所述。

Output Format

输出 \(T\) 行，每行包含一个整数，表示字符串 \(S\) 所有子串的所有拆分中，总共有多少个是优秀的拆分。

Sample

input

4
aabbbb
cccccc
aabaabaabaa
bbaabaababaaba

output

3
5
4
7

Explanation

Explanation for Input

我们用 \(S[i, j]\) 表示字符串 \(S\) 第 \(i\) 个字符到第 \(j\) 个字符的子串（从 \(1\) 开始计数）。

第一组数据中，共有 \(3\) 个子串存在优秀的拆分：

\(S[1,4] = \mathtt{aabb}\)，优秀的拆分为 \(A=\mathtt{a}\)，\(B = \mathtt{b}\)；

\(S[3,6] = \mathtt{bbbb}\)，优秀的拆分为 \(A=\mathtt{b}\)，\(B = \mathtt{b}\)；

\(S[1,6] = \mathtt{aabbbb}\)，优秀的拆分为 \(A= \mathtt{a}\)，\(B = \mathtt{bb}\)。

而剩下的子串不存在优秀的拆分，所以第一组数据的答案是 \(3\)。

第二组数据中，有两类，总共 \(4\) 个子串存在优秀的拆分：

对于子串 \(S[1,4] = S[2,5] = S[3,6] = \mathrm{cccc}\)，它们优秀的拆分相同，均为 \(A = \mathrm{c}\)，\(B = \mathrm{c}\)，但由于这些子串位置不同，因此要计算 \(3\) 次；

对于子串 \(S[1,6] = \mathrm{cccccc}\)，它优秀的拆分有 \(2\) 种：\(A = \mathrm{c}\)，\(B = \mathrm{cc}\) 和 \(A = \mathrm{cc}\)，\(B = \mathrm{c}\)，它们是相同子串的不同拆分，也都要计入答案。

所以第二组数据的答案是 \(3 + 2 = 5\)。

第三组数据中，\(S[1,8]\) 和 \(S[4,11]\) 各有 \(2\) 种优秀的拆分，其中 \(S[1,8]\) 是问题描述中的例子，所以答案是 \(2 + 2 = 4\)。

第四组数据中，\(S[1,4]\)，\(S[6,11]\)，\(S[7,12]\)，\(S[2,11]\)，\(S[1,8]\) 各有 \(1\) 种优秀的拆分，\(S[3,14]\) 有 \(2\) 种优秀的拆分，所以答案是 \(5 + 2 = 7\)。

Range

对于全部的测试点,保证 \(1 \le T \le 10\)。以下对数据的限制均是对于单组输入数据而言的，也就是说同一个测试点下的 \(T\) 组数据均满足限制条件。

我们假定 \(n\) 为字符串 \(S\) 的长度，每个测试点的详细数据范围见下表：

测试点编号	\(n\)	其他约束
1、2	\(\leq 300\)	\(S\)中所有字符全部相同
3、4	\(\leq 2000\)
5、6	\(\leq 10\)	无
7、8	\(\leq 20\)
9、10	\(\leq 30\)
11、12	\(\leq 50\)
13、14	\(\leq 100\)
15	\(\leq 200\)
16	\(\leq 300\)
17	\(\leq 500\)
18	\(\leq 1000\)
19	\(\leq 2000\)
20	\(\leq 30000\)

Algorithm

后缀数组，差分。

Mentality

拿到题目先看看数据范围，嗯 \(......?\) 九十五分的 \(n^2\) 暴力算什么，那考场上谁会打正解， 看着就很显然啊，我们记录 \(a[i]\) 为以 \(i\) 结尾的形如 \(AA\) 的字符串的数量，\(b[i]\) 为以 \(i\) 开头的形如 \(AA\) 的字符串的数量，那么以 \(i\) 为 \(AA\) 与 \(BB\) 的分界线的答案不就是 \(a[i]*b[i+1]\) 吗 = =。

那 \(Ans=\sum a[i]*b[i+1]\) 就好了，计算每个 \(a[i]\) 的时候 \(O(n)\) 枚举 \(AA\) 串的起点或终点，利用 \(hash\) 来 \(O(1)\) 判断它能不能从中间分成相同的两个字符串就好。

\(n^2\) 有 \(95\) 分真的仙 \(......\)

那么我们接着考虑一下如何做 \(100\) 分。打表即可。

首先观察到，假设我们每隔 \(len\) 就标记一个点的话，若两个相邻的标记点之间的 后缀的最长公共前缀(\(LCP\))+前缀的最长公共后缀(\(LCS\)) \(\ge len\) 的话，就是如下情况：

当然，这里还有一个问题：如何求出 \(LCS\) 与 \(LCP\) 呢？其实很简单，我们来感性理解一下后缀数组中的 \(height\) 数组的含义。如果我们将所有后缀数组拿出来建一颗 \(Trie\) 树，那么 \(height\) 数组是不是可以理解为两个相邻叶子节点的 \(lca\) 的深度呢？那么根据 \(rmq\) 求 \(lca\) 的原理，两个后缀的最长公共前缀的长度，不就是它们之间的每两个叶子节点的 \(lca\) 中深度最小的那个，也就是夹在它们中间的 \(height\) 数组中最小的那个吗？

用 \(rmq\) 预处理即可 \(O(1)\) 查询两个后缀的最长公共前缀了。

继续来看上图，蓝色的即为 \(LCP\) ，红色部分为 \(LCS\) 。设它们的重合部分长度为 \(same\) ，对于这种情况，我们不难发现，对于 \(i-LCS\) 到 \(i-LCS+same\) 的位置，以它们为开头的长度为 \(2*len\) 的串必定为 \(AA\) 形式的串。

我觉得这甚至是不需要证明的，因为从中间分开必定相等，实在想不出来在纸上画一画就行。

那么同理，以 \(i-LCS+2*len-1\) 到 \(i-LCS+same+2*len-1\) 结尾的长度为 \(2*len\) 的串也必定为 \(AA\) 形式。

则我们对于相邻的两个距离为 \(len\) 的点，如果它们的 \(LCP+LCS\ge len\) ，那么对于 \(b[i-LCS]\) 至 \(b[i-LCS+same]\) 的位置，我们都加上 \(1\) ，对于 \(a[i-LCS+2*len-1]\) 至 \(a[i-LCS+same+2*len-1\) 的位置，我们也都加上一，这便是当前这两个距离为 \(len\) 的点对 \(a,b\) 数组的贡献了。

对于这个加上去的过程，我们可以使用差分。

那么答案就很明显可以直接统计了。

总结下来我们的步骤如下：

• 枚举 \(len\) ，每隔 \(len\) 便标记一个点，这个的复杂度请百度 调和级数 ，复杂度为 \(nlog\) 。
• 差分数组更改，复杂度 \(O(1)\)
• 统计答案，复杂度 \(O(n)\)

则最后的时间复杂度为 \(O(nlog+n)=O(nlog)\) 。

完毕。

代码细节较多，建议稍稍看一下，不愧是当年的防 \(AK\) 题 \(QwQ\) 。

Code

#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
int p, T, n, M, cnt, tag[30001], sa[2][30001], rk[2][30001], h[2][30001],
    tp[2][30001], rmq[2][30001][16], Log[40001], a[30002], b[30002];
long long ans;
char s[2][30002];
void Sort(int x) {
  for (int i = 1; i <= M; i++) tag[i] = 0;
  for (int i = 1; i <= n; i++) tag[rk[x][i]]++;
  for (int i = 1; i <= M; i++) tag[i] += tag[i - 1];
  for (int i = n; i >= 1; i--) sa[x][tag[rk[x][tp[x][i]]]--] = tp[x][i];
}
int find(int x, int l, int r) {
  if (l > r) swap(l, r);
  l++;
  int L = Log[r - l + 1];
  return min(rmq[x][l][L], rmq[x][r - (1 << L) + 1][L]);
}
int main() {
  cin >> T;
  int now = 1, num = -1, top = 2;
  Log[1] = 0;
  for (int i = 1; i <= 15; i++) {
    now <<= 1, num++;
    while (top <= now) Log[top++] = num;
  }  //预处理 log
  while (T--) {
    memset(a, 0, sizeof(a));
    memset(b, 0, sizeof(b));
    memset(rk, 0, sizeof(rk));
    memset(tp, 0, sizeof(tp));
    scanf("%s", s[0] + 1);
    n = strlen(s[0] + 1);
    for (int i = 1; i <= n; i++)
      s[1][i] = s[0][n - i + 1];  //反过来方便处理前缀
    M = 76;
    for (int i = 1; i <= n; i++) rk[0][i] = s[0][i] - 'a' + 1, tp[0][i] = i;
    for (int i = n; i >= 1; i--) rk[1][i] = s[1][i] - 'a' + 1, tp[1][i] = i;
    Sort(0), Sort(1);
    for (int l = 0; l < 2; l++) {
      cnt = 0;
      for (int len = 1; cnt < n; len <<= 1, M = cnt) {
        cnt = 0;
        for (int i = n - len + 1; i <= n; i++) tp[l][++cnt] = i;
        for (int i = 1; i <= n; i++)
          if (sa[l][i] > len) tp[l][++cnt] = sa[l][i] - len;
        Sort(l);
        swap(tp[l], rk[l]);
        rk[l][sa[l][1]] = cnt = 1;
        for (int i = 2; i <= n; i++)
          rk[l][sa[l][i]] =
              tp[l][sa[l][i]] == tp[l][sa[l][i - 1]] &&
                      tp[l][sa[l][i] + len] == tp[l][sa[l][i - 1] + len]
                  ? cnt
                  : ++cnt;
      }
    }  //后缀与前缀的排序
    for (int l = 0; l < 2; l++) {
      for (int i = 1, len = 0; i <= n; i++) {
        if (len) len--;
        int now = sa[l][rk[l][i] - 1];
        while (s[l][now + len] == s[l][i + len]) len++;
        rmq[l][rk[l][i]][0] = len;
      }
      for (int j = 1; j <= 15; j++)
        for (int i = 1; i <= n; i++)
          if (i + (1 << (j - 1)) <= n)
            rmq[l][i][j] =
                min(rmq[l][i][j - 1], rmq[l][i + (1 << (j - 1))][j - 1]);
    }  // height 数组与 rmq 预处理
    for (int len = 1; len <= n / 2; len++)
      for (int i = len; i + len <= n; i += len) {
        int l = i, r = i + len;
        int LCS = find(1, rk[1][n - r + 2], rk[1][n - l + 2]),
            LCP = find(0, rk[0][l], rk[0][r]);  //计算 LCS 与 LCP
        LCS = min(LCS, len - 1),
        LCP = min(
            LCP,
            len);  //如果 LCS 或 LCP 过大，则会在其他点算重，所以和 len 取 min
        if (LCS + LCP >= len) {
          int same = LCS + LCP - len + 1;
          b[l - LCS]++, b[l - LCS + same]--;
          a[l - LCS + 2 * len - 1]++, a[l - LCS + same + 2 * len - 1]--;
        }  //差分数组更改
      }
    for (int i = 1; i <= n; i++)
      a[i] += a[i - 1], b[i] += b[i - 1];  //计算差分数组真实值
    ans = 0;
    for (int i = 1; i < n; i++) ans += a[i] * b[i + 1];  //计算答案
    cout << ans << endl;
  }
}