回文树/自动机 (Palindromic Tree/Automaton)

回文树/自动机 (Palindromic Tree/Automaton)

回文树, 又称回文自动机 (PAM), 用来解决字符串的回文子串问题.

推荐先学 后缀自动机, AC 自动机, 三者会有很多相似之处, 学起来会更加愉快. 而 Manacher 的内容一点也没有用到, 无需为了学 PAM 特意学习.

定义

形态上是两棵树 + (Link).

每个节点表示一个本质不同的回文子串. 该串长度即为该节点长度.

树边带权, 是自动机的转移边. 权值为一个字符 (c), 表示起点两端同时加 (c) 得到的新串存在并且作为另一个回文子串.

因为奇数长度的节点只能转移到奇数长度的节点, 所以存在两个根, 分别作为奇树和偶树的根.

(Link) 边向长度小的节点转移, 表示该点最大的回文后缀. (Link) 可以在两树之间连接.

建立一个数组 (Order), 其中 (Order_i) 表示原字符串中以第 (i) 个字符为结尾的最长的回文子串的节点位置. 由于 (Order_i) 的 (Link) 是 (Order_i) 的最长回文后缀. 所以通过 (Order) 所在的 (Link) 链可以访问以任意字符为结尾的的回文后缀.

构造

一开始是空串, 只有两个根, 偶根 (Link) 连奇根. 考虑将一个字符 (c) 加入到已经构建回文自动机的 (s) 的后面会在哪里出现回文串.

如果原来 (s) 的后缀是回文串, 从 (Order_{len_s}) 往 (Link) 链上跳. 如果 (s) 有回文后缀为 ([a, b]), 满足 (s{b + 1} = s_{a - 1} = c), 则出现回文串 ([a - 1, b + 1]), 新建这个节点, 连接转移 (c), 将 (Order_{len_s + 1}) 指向 ([a - 1, b + 1]) 所在节点.

这时就有人要问了, 如果有多个节点需要新建呢? 但是再审视一下回文后缀的性质, 每次新建的点真的不止一个吗?

如果 (s + c) 的最长回文后缀是 ([a - 1, b + 1]), 仍存在一个比 (b - a + 1) 短的回文后缀 ([c, b + 1]). 因为 ([a - 1, b + 1]) 是回文串, 所以 ([a - 1, a - 1 + b - c]) 也是一个和 ([c, b + 1]) 本质相同的回文串. 所以不存在第二个新回文子串. 也就是说, 每个字符 (c) 的加入最多带来一个新节点.

接下来考虑 (Link) 的连接, 设节点 (A) 在 (Order_{len_s}) 的 (Link) 上, 则 (A) 是 (Order_{len_s}) 的后缀. 只要 (len_A + 1 leq len_{Order_{len_s + 1}}), 那么 (A + c) 就是 (Order_{len_s}) 的后缀.

只要判断 (c + A + c) 是否是 (Order_{len_s}) 的后缀即可 (当然 (A) 要有转移 (c), 否则根本不存在 (c + A + c) 对应的节点). 在跳 (Link) 的时候, 判断 (A ightarrow c) ((A) 的转移 (c) 指向的节点) 的左端字符 (c) 是否和 (Order_{len_s + 1}) 对应位置的字符对应 (即判断是否有 (s_{len_s - len_A} = c) 成立). 如果到最后没有找到合法的 (Link), 连向偶根.

以此类推, 将每个字符都插入后, 便构造了一个回文自动机.

下面对复杂度进行证明, 同样是将字符集规模看作常数.

空间复杂度

因为一个节点只有一个树上入边, 一个 (Link) 出边. 空间复杂度取决于节点数, 每个节点和一个本质不同的回文子串一一对应, 只要分析本质不同的回文子串数量即可. 因为一共有 (n) 个字符, 之前已经说明, 每个字符的加入最多新出现一个本质不同的回文串, 所以最多有 (n) 个本质不同的回文串. 空间复杂度为 (O(n))

时间复杂度

除了跳 (Order_{len_s}) 的 (Link) 链, 其它部分都是显然的线性复杂度, 所以着重分析跳 (Link) 的复杂度.

在 (Order_{len_s}) 的 (Link) 链上的满足以上条件的节点, 可能是 (Order_{len_s}). 这样一来, (Order_{len_s + 1}) 的 (Link) 只要连向 (Order_{len_s + 1}), 就能使 (Order_{len_s + 1}) 的 (Link) 链长比 (Order_{len_s}) 的 (Link) 链长大 (1).

每次跳 (Link), (Order_{len_s}) 的 (Link) 链长度都会减少 (1). 而每次最多在一个 (Link) 不跳的情况下使 (Link) 链比上一个 (Link) 链长 (1). 所以总的跳 (Link) 的总次数是线性的.

所以总复杂度是 (O(n))

模板

求一个长度为 (n) 的字符串的每一个前缀的回文后缀数量. ((n leq 5 * 10^5))

前缀 ([1, i]) 的回文后缀数也就是 (Order_i) 所在的 (Link) 链去掉两根的长度. 建立 PAM, 记忆化搜索统计长度即可.

代码

缺省源省略, fread() 需要 <cstdio>

unsigned m, n, Cnt(0), Ans(0), Tmp(0), Key;
bool flg(0);
char a[500005];
struct Node {
  Node *Link, *To[26];
  int Len;
  unsigned int LinkLength; 
}N[500005], *Order[500005], *CntN(N + 1), *Now(N), *Last(N);
int main() {
  fread(a + 1, 1, 500003, stdin);
  n = strlen(a + 1);
  N[0].Len = -1;
  N[1].Link = N;
  N[1].Len = 0;
  Order[0] = N + 1;
  for (register unsigned i(1); i <= n; ++i) {
    if(a[i] < 'a' || a[i] > 'z') {
      continue;
    }
    Now = Last = Order[i - 1];
    a[i] -= 'a';
    a[i] = ((unsigned)a[i] + Key) % 26;
    while (Now) {
      if(Now->Len + 1 < i) {
        if(a[i - Now->Len - 1] == a[i]) { // 符合左端字符对应位置是 c 
          if(Now->To[a[i]]) {             // 有转移 c, 不新建节点, 只记录 Order 
            Order[i] = Now->To[a[i]];
            flg = 1;                      // 标记表示本轮没有节点被新建 
          }
          else {
            Now->To[a[i]] = ++CntN;       // 转移 
            CntN->Len = Now->Len + 2;     // 长度 +2 (左右两端加 c) 
            Order[i] = CntN;              // 记录 Order 
          }
          break; 
        }
      }
      Last = Now;                         // 记录上一个节点, 优化下一次跳 Link 链的次数 (下一次跳是找 Order_i 的 Link) 
      Now = Now->Link;                    // 跳 Link 
    }
    if(!flg) {                                    // 有新节点, 连接这个点的 Link 
      Now = Last;
      while (Now) {
        if(Now->To[a[i]]) {                       // 有转移 c 
          if(Now->To[a[i]]->Len < Order[i]->Len) {// 长度合法 
            if(a[i - Now->Len - 1] == a[i]) {     // 该节点左端包含于 Order_i->Link 的后缀 
              Order[i]->Link = Now->To[a[i]];
              Order[i]->LinkLength = Now->To[a[i]]->LinkLength + 1;
              break;                              // 找到 Link 
            }
          }
        }
        Now = Now->Link;                          // 跳 Link 
      }
      if(!Now) {    // 无合适的 Link, 连向偶根 
        Order[i]->Link = N + 1;
        Order[i]->LinkLength = 1;
      }
    }
    else {          // 有标记说明无新节点, 清空标记 
      flg = 0;
    }
    Key = Order[i]->LinkLength;
    printf("%d ", Key);
  }
  return Wild_Donkey;
}