跳转至

# 回文树

## 定义

回文树（EER Tree，Palindromic Tree，也被称为回文自动机）是一种可以存储一个串中所有回文子串的高效数据结构．最初由 Mikhail Rubinchik 和 Arseny M. Shur 在 2015 年发表．它的灵感来源于后缀树等字符串后缀数据结构，使用回文树可以简单高效地解决一系列涉及回文串的问题．

## 结构

回文树大概长这样

和其它自动机类似的，回文树也是由转移边和后缀链接（fail 指针）组成，每个节点都可以代表一个回文子串．

因为回文串长度分为奇数和偶数，我们可以像 manacher 那样加入一个不在字符集中的字符（如 '#'）作为分隔符来将所有回文串的长度都变为奇数，但是这样过于麻烦了．有没有更好的办法呢？

答案自然是有．更好的办法就是建两棵树，一棵树中的节点对应的回文子串长度均为奇数，另一棵树中的节点对应的回文子串长度均为偶数．

和其它的自动机一样，一个节点的 fail 指针指向的是这个节点所代表的回文串的最长回文后缀所对应的节点，但是转移边并非代表在原节点代表的回文串后加一个字符，而是表示在原节点代表的回文串前后各加一个相同的字符（不难理解，因为要保证存的是回文串）．

我们还需要在每个节点上维护此节点对应回文子串的长度 len，这个信息保证了我们可以轻松地构造出回文树．

## 建造

回文树有两个初始状态，分别代表长度为 −1,0−1,0 的回文串．我们可以称它们为奇根，偶根．它们不表示任何实际的字符串，仅作为初始状态存在，这与其他自动机的根节点是异曲同工的．

偶根的 fail 指针指向奇根，而我们并不关心奇根的 fail 指针，因为奇根不可能失配（奇根转移出的下一个状态长度为 1 1，即单个字符．一定是回文子串）

类似后缀自动机，我们增量构造回文树．

考虑构造完前 𝑝 −1 p−1 个字符的回文树后，向自动机中添加在原串里位置为 𝑝 p 的字符．

我们从以上一个字符结尾的最长回文子串对应的节点开始，不断沿着 fail 指针走，直到找到一个节点满足 𝑠 𝑝 =𝑠 𝑝−𝑙 𝑒 𝑛−1 s p=s p−l e n−1，即满足此节点所对应回文子串的上一个字符与待添加字符相同．

这里贴出论文中的那张图

我们通过跳 fail 指针找到 A 所对应的节点，然后两边添加 `X` 就到了现在的回文串了（即 `XAX`），很显然，这个节点就是以 𝑝 p 结尾的最长回文子串对应的树上节点．（同时，这个时候长度 −1−1 节点优势出来了，如果没有 `X` 能匹配条件就是同一个位置的 𝑠 𝑝 =𝑠 𝑝 s p=s p，就自然得到了代表字符 `X` 的节点．）此时要判断一下：没有这个节点，就需要新建．

然后我们还需要求出新建的节点的 fail 指针．具体方法与上面的过程类似，不断跳转 fail 指针，从 `A` 出发，即可找到 `XAX` 的最长回文后缀 `XBX`，将对应节点设为 fail 指针所指的对象即可．

显然，这个节点是不需新建的，`A` 的前 𝑙 𝑒 𝑛 𝐵 l e n B 位和后 𝑙 𝑒 𝑛 𝐵 l e n B 位相同，都是 `B`，前 𝑙 𝑒 𝑛 𝐵 l e n B 位的两端根据回文串对应关系，都是 `X`，后面被钦定了是 `X`，于是这个节点 `XBX` 肯定已经被包含了．

如果 fail 没匹配到，那么将它连向长度为 0 0 的那个节点，显然这是可行的（因为这是所有节点的后缀）．

## 线性状态数证明

### 定理

对于一个字符串 𝑠 s，它的本质不同回文子串个数最多只有 |𝑠||s| 个．

### 证明

考虑使用数学归纳法．

- 当 |𝑠| =1|s|=1 时，𝑠 s 只有一个字符，同时也只有一个子串，并且这个子串是回文的，因此结论成立．

- 当 |𝑠| >1|s|>1 时，设 𝑡 =𝑠 𝑐 t=s c，其中 𝑡 t 表示 𝑠 s 最后增加一个字符 𝑐 c 后形成的字符串，假设结论对 𝑠 s 串成立．考虑以最后一个字符 𝑐 c 结尾的回文子串，假设它们的左端点由小到大排序为 𝑙 1,𝑙 2,…,𝑙 𝑘 l 1,l 2,…,l k．由于 𝑡[𝑙 1..|𝑡|]t[l 1..|t|] 是回文串，因此对于所有位置 𝑙 1 ≤𝑝 ≤|𝑡|l 1≤p≤|t|，有 𝑡[𝑝..|𝑡|] =𝑡[𝑙 1..𝑙 1 +|𝑡| −𝑝]t[p..|t|]=t[l 1..l 1+|t|−p]．所以，对于 1 <𝑖 ≤𝑘 1<i≤k，𝑡[𝑙 𝑖..|𝑡|]t[l i..|t|] 已经在 𝑡[1..|𝑡| −1]t[1..|t|−1] 中出现过．因此，每次增加一个字符，本质不同的回文子串个数最多增加 1 1 个．

由数学归纳法，可知该定理成立．

因此回文树状态数是 𝑂(|𝑠|)O(|s|) 的．对于每一个状态，它实际只代表一个本质不同的回文子串，即转移到该节点的状态唯一，因此总转移数也是 𝑂(|𝑠|)O(|s|) 的．

## 正确性证明

以上图为例，增加当前字符 `X`，由线性状态数的证明，我们只需要找到包含最后一个字符 `X` 的最长回文后缀，也就是 `XAX`．继续寻找 `XAX` 的最长回文后缀 `XBX`，建立后缀链接．`XBX` 对应状态已经在回文树中出现，包含最后一个字符的回文后缀就是 `XAX`，`XBX` 本身及其对应状态在 fail 树上的所有祖先．

对于 𝑠 s 回文树的构造，令 𝑛 =|𝑠|n=|s|，显然除了跳 fail 指针的其他操作都是 𝑂(𝑛)O(n) 的．

加入字符时，在上一次的基础上，每次跳 fail 后对应节点在 fail 树的深度 −1−1，而连接 fail 后，仅为深度 + 1（但 fail 为 0 0 时（即到 −1−1 才符合），深度相当于在 −1−1 的基础上 +2+2）．

因为只加入 𝑛 n 个字符，所以只会加 𝑛 n 次深度，最多也只会跳 2 𝑛 2 n 次 fail．

因此，构造 𝑠 s 的回文树的时间复杂度是 𝑂(|𝑠|)O(|s|)．

## 应用

### 本质不同回文子串个数

由线性状态数的证明，容易知道一个串的本质不同回文子串个数等于回文树的状态数（排除奇根和偶根两个状态）．

### 回文子串出现次数

建出回文树，使用类似后缀自动机统计出现次数的方法．

由于回文树的构造过程中，节点本身就是按照拓扑序插入，因此只需要逆序枚举所有状态，将当前状态的出现次数加到其 fail 指针对应状态的出现次数上即可．

例题：「APIO2014」回文串

定义 𝑠 s 的一个子串的存在值为这个子串在 𝑠 s 中出现的次数乘以这个子串的长度．对于给定的字符串 𝑠 s，求所有回文子串中的最大存在值．

参考代码

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    #include <algorithm>
    #include <cstring>
    #include <iostream>
    #include <string>
    using namespace std;
    constexpr int MAXN = 300000 + 5;

    namespace pam {
    int sz, tot, last;
    int cnt[MAXN], ch[MAXN][26], len[MAXN], fail[MAXN];
    char s[MAXN];

    int node(int l) {  // 建立一个新节点，长度为 l
      sz++;
      memset(ch[sz], 0, sizeof(ch[sz]));
      len[sz] = l;
      fail[sz] = cnt[sz] = 0;
      return sz;
    }

    void clear() {  // 初始化
      sz = -1;
      last = 0;
      s[tot = 0] = '$';
      node(0);
      node(-1);
      fail[0] = 1;
    }

    int getfail(int x) {  // 找后缀回文
      while (s[tot - len[x] - 1] != s[tot]) x = fail[x];
      return x;
    }

    void insert(char c) {  // 建树
      s[++tot] = c;
      int now = getfail(last);
      if (!ch[now][c - 'a']) {
        int x = node(len[now] + 2);
        fail[x] = ch[getfail(fail[now])][c - 'a'];
        ch[now][c - 'a'] = x;
      }
      last = ch[now][c - 'a'];
      cnt[last]++;
    }

    long long solve() {
      long long ans = 0;
      for (int i = sz; i >= 0; i--) {
        cnt[fail[i]] += cnt[i];
      }
      for (int i = 1; i <= sz; i++) {  // 更新答案
        ans = max(ans, 1ll * len[i] * cnt[i]);
      }
      return ans;
    }
    }  // namespace pam

    string s;

    int main() {
      cin.tie(nullptr)->sync_with_stdio(false);
      pam::clear();
      cin >> s;
      for (int i = 0; i < s.size(); i++) {
        pam::insert(s[i]);
      }
      cout << pam::solve() << '\n';
      return 0;
    }

### 最小回文划分

> 给定一个字符串 𝑠(1 ≤|𝑠| ≤1 0 5)s(1≤|s|≤10 5)，求最小的 𝑘 k，使得存在 𝑠 1,𝑠 2,…,𝑠 𝑘 s 1,s 2,…,s k，满足 𝑠 𝑖(1 ≤𝑖 ≤𝑘)s i(1≤i≤k) 均为回文串，且 𝑠 1,𝑠 2,…,𝑠 𝑘 s 1,s 2,…,s k 依次连接后得到的字符串等于 𝑠 s．

考虑动态规划，记 𝑑 𝑝[𝑖]d p[i] 表示 𝑠 s 长度为 𝑖 i 的前缀的最小划分数，转移只需要枚举以第 𝑖 i 个字符结尾的所有回文串

𝑑 𝑝[𝑖]=1+m i n 𝑠[𝑗+1..𝑖] 为回文串 𝑑 𝑝[𝑗]d p[i]=1+min s[j+1..i] 为回文串 d p[j]

由于一个字符串最多会有 𝑂(𝑛 2)O(n 2) 个回文子串，因此上述算法的时间复杂度为 𝑂(𝑛 2)O(n 2)，无法接受，为了优化转移过程，下面给出一些引理．

记字符串 𝑠 s 长度为 𝑖 i 的前缀为 𝑝 𝑟 𝑒(𝑠,𝑖)p r e(s,i)，长度为 𝑖 i 的后缀为 𝑠 𝑢 𝑓(𝑠,𝑖)s u f(s,i)．

周期：若 0 <𝑝 ≤|𝑠|0<p≤|s|，∀1 ≤𝑖 ≤|𝑠| −𝑝,𝑠[𝑖] =𝑠[𝑖 +𝑝]∀1≤i≤|s|−p,s[i]=s[i+p]，就称 𝑝 p 是 𝑠 s 的周期．

border：若 0 ≤𝑟 <|𝑠|0≤r<|s|，𝑝 𝑟 𝑒(𝑠,𝑟) =𝑠 𝑢 𝑓(𝑠,𝑟)p r e(s,r)=s u f(s,r)，就称 𝑝 𝑟 𝑒(𝑠,𝑟)p r e(s,r) 是 𝑠 s 的 border．

周期和 border 的关系：𝑡 t 是 𝑠 s 的 border，当且仅当 |𝑠| −|𝑡||s|−|t| 是 𝑠 s 的周期．

证明

若 𝑡 t 是 𝑠 s 的 border，那么 𝑝 𝑟 𝑒(𝑠,|𝑡|) =𝑠 𝑢 𝑓(𝑠,|𝑡|)p r e(s,|t|)=s u f(s,|t|)，因此 ∀1 ≤𝑖 ≤|𝑡|,𝑠[𝑖] =𝑠[|𝑠| −|𝑡| +𝑖]∀1≤i≤|t|,s[i]=s[|s|−|t|+i]，所以 |𝑠| −|𝑡||s|−|t| 就是 𝑠 s 的周期．

若 |𝑠| −|𝑡||s|−|t| 为 𝑠 s 周期，则 ∀1 ≤𝑖 ≤|𝑠| −(|𝑠| −|𝑡|) =|𝑡|,𝑠[𝑖] =𝑠[|𝑠| −|𝑡| +𝑖]∀1≤i≤|s|−(|s|−|t|)=|t|,s[i]=s[|s|−|t|+i]，因此 𝑝 𝑟 𝑒(𝑠,|𝑡|) =𝑠 𝑢 𝑓(𝑠,|𝑡|)p r e(s,|t|)=s u f(s,|t|)，所以 𝑡 t 是 𝑠 s 的 border．

#### 引理一

𝑡 t 是回文串 𝑠 s 的后缀，𝑡 t 是 𝑠 s 的 border 当且仅当 𝑡 t 是回文串．

证明

对于 1 ≤𝑖 ≤|𝑡|1≤i≤|t|，由 𝑠 s 和 𝑡 t 为回文串，因此有 𝑠[𝑖] =𝑠[|𝑠| −𝑖 +1] =𝑠[|𝑠| −|𝑡| +𝑖]s[i]=s[|s|−i+1]=s[|s|−|t|+i]，所以 𝑡 t 是 𝑠 s 的 border．

对于 1 ≤𝑖 ≤|𝑡|1≤i≤|t|，由 𝑡 t 是 𝑠 s 的 border，有 𝑠[𝑖] =𝑠[|𝑠| −|𝑡| +𝑖]s[i]=s[|s|−|t|+i]，由 𝑠 s 是回文串，有 𝑠[𝑖] =𝑠[|𝑠| −𝑖 +1]s[i]=s[|s|−i+1]，因此 𝑠[|𝑠| −𝑖 +1] =𝑠[|𝑠| −|𝑡| +𝑖]s[|s|−i+1]=s[|s|−|t|+i]，所以 𝑡 t 是回文串．

下图中，相同颜色的位置表示字符对应相同．

#### 引理二

𝑡 t 是串 𝑠 s 的 border (|𝑠| ≤2|𝑡||s|≤2|t|)，𝑠 s 是回文串当且仅当 𝑡 t 是回文串．

证明

若 𝑠 s 是回文串，由引理 1 1，𝑡 t 也是回文串．

若 𝑡 t 是回文串，由 𝑡 t 是 𝑠 s 的 border，因此 ∀1 ≤𝑖 ≤|𝑡|,𝑠[𝑖] =𝑠[|𝑠| −|𝑡| +𝑖] =𝑠[|𝑠| −𝑖 +1]∀1≤i≤|t|,s[i]=s[|s|−|t|+i]=s[|s|−i+1]，因为 |𝑠| ≤2|𝑡||s|≤2|t|，所以 𝑠 s 也是回文串．

#### 引理三

𝑡 t 是回文串 𝑠 s 的 border，则 |𝑠| −|𝑡||s|−|t| 是 𝑠 s 的周期，|𝑠| −|𝑡||s|−|t| 为 𝑠 s 的最小周期，当且仅当 𝑡 t 是 𝑠 s 的最长回文真后缀．

#### 引理四

𝑥 x 是一个回文串，𝑦 y 是 𝑥 x 的最长回文真后缀，𝑧 z 是 𝑦 y 的最长回文真后缀．令 𝑢,𝑣 u,v 分别为满足 𝑥 =𝑢 𝑦,𝑦 =𝑣 𝑧 x=u y,y=v z 的字符串，则有下面三条性质

1. |𝑢| ≥|𝑣||u|≥|v|；

2. 如果 |𝑢| >|𝑣||u|>|v|，那么 |𝑢| >|𝑧||u|>|z|；

3. 如果 |𝑢| =|𝑣||u|=|v|，那么 𝑢 =𝑣 u=v．

证明

1. 由引理 3 3 的推论，|𝑢| =|𝑥| −|𝑦||u|=|x|−|y| 是 𝑥 x 的最小周期，|𝑣| =|𝑦| −|𝑧||v|=|y|−|z| 是 𝑦 y 的最小周期．考虑反证法，假设 |𝑢| <|𝑣||u|<|v|，因为 𝑦 y 是 𝑥 x 的后缀，所以 𝑢 u 既是 𝑥 x 的周期，也是 𝑦 y 的周期，而 |𝑣||v| 是 𝑦 y 的最小周期，矛盾．所以 |𝑢| ≥|𝑣||u|≥|v|．
2. 因为 𝑦 y 是 𝑥 x 的 border，所以 𝑣 v 是 𝑥 x 的前缀，设字符串 𝑤 w，满足 𝑥 =𝑣 𝑤 x=v w（如下图所示），其中 𝑧 z 是 𝑤 w 的 border．考虑反证法，假设 |𝑢| ≤|𝑧||u|≤|z|，那么 |𝑧 𝑢| ≤2|𝑧||z u|≤2|z|，所以由引理 2 2，𝑤 w 是回文串，由引理 1 1，𝑤 w 是 𝑥 x 的 border，又因为 |𝑢| >|𝑣||u|>|v|，所以 |𝑤| >|𝑦||w|>|y|，矛盾．所以 |𝑢| >|𝑧||u|>|z|．
3. 𝑢,𝑣 u,v 都是 𝑥 x 的前缀，|𝑢| =|𝑣||u|=|v|，所以 𝑢 =𝑣 u=v．

#### 推论

𝑠 s 的所有回文后缀按照长度排序后，可以划分成 l o g⁡|𝑠|log⁡|s| 段等差数列．

证明

设 𝑠 s 的所有回文后缀长度从小到大排序为 𝑙 1,𝑙 2,…,𝑙 𝑘 l 1,l 2,…,l k．对于任意 2 ≤𝑖 ≤𝑘 −1 2≤i≤k−1，若 𝑙 𝑖 −𝑙 𝑖−1 =𝑙 𝑖+1 −𝑙 𝑖 l i−l i−1=l i+1−l i，则 𝑙 𝑖−1,𝑙 𝑖,𝑙 𝑖+1 l i−1,l i,l i+1 构成一个等差数列．否则 𝑙 𝑖 −𝑙 𝑖−1 ≠𝑙 𝑖+1 −𝑙 𝑖 l i−l i−1≠l i+1−l i，由引理 4 4，有 𝑙 𝑖+1 −𝑙 𝑖 >𝑙 𝑖 −𝑙 𝑖−1 l i+1−l i>l i−l i−1，且 𝑙 𝑖+1 −𝑙 𝑖 >𝑙 𝑖−1 l i+1−l i>l i−1，𝑙 𝑖+1 >2 𝑙 𝑖−1 l i+1>2 l i−1．因此，若相邻两对回文后缀的长度之差发生变化，那么这个最大长度一定会相对于最小长度翻一倍．显然，长度翻倍最多只会发生 𝑂(l o g⁡|𝑠|)O(log⁡|s|) 次，也就是 𝑠 s 的回文后缀长度可以划分成 l o g⁡|𝑠|log⁡|s| 段等差数列．

该推论也可以通过使用弱周期引理，对 𝑠 s 的最长回文后缀的所有 border 按照长度 𝑥 x 分类，𝑥 ∈[2 0,2 1),[2 1,2 2),…,[2 𝑘,𝑛)x∈[2 0,2 1),[2 1,2 2),…,[2 k,n)，考虑这 l o g⁡|𝑠|log⁡|s| 组内每组的最长 border 进行证明．详细证明可以参考金策的《字符串算法选讲》和陈孙立的 2019 年 IOI 国家候选队论文《子串周期查询问题的相关算法及其应用》．

有了这个结论后，我们现在可以考虑如何优化 𝑑 𝑝 d p 的转移．

#### 优化

回文树上的每个节点 𝑢 u 需要多维护两个信息，𝑑 𝑖 𝑓 𝑓[𝑢]d i f f[u] 和 𝑠 𝑙 𝑖 𝑛 𝑘[𝑢]s l i n k[u]．𝑑 𝑖 𝑓 𝑓[𝑢]d i f f[u] 表示节点 𝑢 u 和 𝑓 𝑎 𝑖 𝑙[𝑢]f a i l[u] 所代表的回文串的长度差，即 𝑙 𝑒 𝑛[𝑢] −𝑙 𝑒 𝑛[𝑓 𝑎 𝑖 𝑙[𝑢]]l e n[u]−l e n[f a i l[u]]．𝑠 𝑙 𝑖 𝑛 𝑘[𝑢]s l i n k[u] 表示 𝑢 u 一直沿着 fail 向上跳到第一个节点 𝑣 v，使得 𝑑 𝑖 𝑓 𝑓[𝑣] ≠𝑑 𝑖 𝑓 𝑓[𝑢]d i f f[v]≠d i f f[u]，也就是 𝑢 u 所在等差数列中长度最小的那个节点．

根据上面证明的结论，如果使用 𝑠 𝑙 𝑖 𝑛 𝑘 s l i n k 指针向上跳的话，每向后填加一个字符，只需要向上跳 𝑂(l o g⁡|𝑠|)O(log⁡|s|) 次．因此，可以考虑将一个等差数列表示的所有回文串的 𝑑 𝑝 d p 值之和（在原问题中指 m i n min），记录到最长的那一个回文串对应节点上．

𝑔[𝑣]g[v] 表示 𝑣 v 所在等差数列的 𝑑 𝑝 d p 值之和，且 𝑣 v 是这个等差数列中长度最长的节点，则 𝑔[𝑣] =∑𝑠 𝑙 𝑖 𝑛 𝑘[𝑥]=𝑠 𝑙 𝑖 𝑛 𝑘[𝑣]𝑑 𝑝[𝑖 −𝑙 𝑒 𝑛[𝑥]]g[v]=∑s l i n k[x]=s l i n k[v]d p[i−l e n[x]]，这里 𝑖 i 是当前枚举到的下标．

下面我们考虑如何更新 𝑔 g 数组和 𝑑 𝑝 d p 数组．以下图为例，假设当前枚举到第 𝑖 i 个字符，回文树上对应节点为 𝑥 x．𝑔[𝑥]g[x] 为橙色三个位置的 𝑑 𝑝 d p 值之和（最短的回文串 𝑠 𝑙 𝑖 𝑛 𝑘[𝑥]s l i n k[x] 算在下一个等差数列中）．𝑓 𝑎 𝑖 𝑙[𝑥]f a i l[x] 上一次出现位置是 𝑖 −𝑑 𝑖 𝑓 𝑓[𝑥]i−d i f f[x]（在 𝑖 −𝑑 𝑖 𝑓 𝑓[𝑥]i−d i f f[x] 处结束），𝑔[𝑓 𝑎 𝑖 𝑙[𝑥]]g[f a i l[x]] 包含的 𝑑 𝑝 d p 值是蓝色位置．因此，𝑔[𝑥]g[x] 实际上等于 𝑔[𝑓 𝑎 𝑖 𝑙[𝑥]]g[f a i l[x]] 和多出来一个位置的 𝑑 𝑝 d p 值之和，多出来的位置是 𝑖 −(𝑙 𝑒 𝑛[𝑠 𝑙 𝑖 𝑛 𝑘[𝑥]] +𝑑 𝑖 𝑓 𝑓[𝑥])i−(l e n[s l i n k[x]]+d i f f[x])．最后再用 𝑔[𝑥]g[x] 去更新 𝑑 𝑝[𝑖]d p[i]，这部分等差数列的贡献就计算完毕了，不断跳 𝑠 𝑙 𝑖 𝑛 𝑘[𝑥]s l i n k[x]，重复这个过程即可．具体实现方式可参考例题代码．

最后，上述做法的正确性依赖于：如果 𝑥 x 和 𝑓 𝑎 𝑖 𝑙[𝑥]f a i l[x] 属于同一个等差数列，那么 𝑓 𝑎 𝑖 𝑙[𝑥]f a i l[x] 上一次出现位置是 𝑖 −𝑑 𝑖 𝑓 𝑓[𝑥]i−d i f f[x]．

证明

根据引理 1 1，𝑓 𝑎 𝑖 𝑙[𝑥]f a i l[x] 是 𝑥 x 的 border，因此其在 𝑖 −𝑑 𝑖 𝑓 𝑓[𝑥]i−d i f f[x] 处出现．

假设 𝑓 𝑎 𝑖 𝑙[𝑥]f a i l[x] 在 (𝑖 −𝑑 𝑖 𝑓 𝑓[𝑥],𝑖)(i−d i f f[x],i) 中的 𝑗 j 位置出现．由于 𝑥 x 和 𝑓 𝑎 𝑖 𝑙[𝑥]f a i l[x] 属于同一个等差数列，因此 2|𝑓 𝑎 𝑖 𝑙[𝑥]| ≥𝑥 2|f a i l[x]|≥x．多余的 𝑓 𝑎 𝑖 𝑙[𝑥]f a i l[x] 和 𝑖 −𝑑 𝑖 𝑓 𝑓[𝑥]i−d i f f[x] 处的 𝑓 𝑎 𝑖 𝑙[𝑥]f a i l[x] 有交集，记交集为 𝑤 w，设串 𝑢 u 满足 𝑢 𝑤 =𝑓 𝑎 𝑖 𝑙[𝑥]u w=f a i l[x]．用类似引理 1 1 的方式可以证明，𝑤 w 是回文串，而 𝑥 x 的前缀 𝑠[𝑖 −𝑙 𝑒 𝑛[𝑥] +1..𝑗] =𝑢 𝑤 𝑢 s[i−l e n[x]+1..j]=u w u 也是回文串，这与 𝑓 𝑎 𝑖 𝑙[𝑥]f a i l[x] 是 𝑥 x 的最长回文前缀（后缀）矛盾．

例题：Codeforces 932G Palindrome Partition

给定一个字符串 𝑠 s，要求将 𝑠 s 划分为 𝑡 1,𝑡 2,…,𝑡 𝑘 t 1,t 2,…,t k，其中 𝑘 k 是偶数，且 𝑡 𝑖 =𝑡 𝑘−𝑖+1 t i=t k−i+1，求这样的划分方案数．

题解

构造字符串 𝑡 = 𝑠[0]𝑠[𝑛 − 1]𝑠[1]𝑠[𝑛 − 2]𝑠[2]𝑠[𝑛 − 3]…𝑠[𝑛 / 2 − 1]𝑠[𝑛 / 2]t= s[0]s[n − 1]s[1]s[n − 2]s[2]s[n − 3]…s[n / 2 − 1]s[n / 2]，问题等价于求 𝑡 t 的偶回文划分方案数，把上面的转移方程改成求和形式并且只在偶数位置更新 𝑑 𝑝 d p 数组即可．时间复杂度 𝑂(𝑛 l o g⁡𝑛)O(n log⁡n)，空间复杂度 𝑂(𝑛)O(n)．

参考代码

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    #include <cstring>
    #include <iostream>
    #include <string>
    using namespace std;
    using ll = long long;
    constexpr int mod = 1e9 + 7;
    constexpr int MAXN = 1000000 + 5;

    int add(int x, int y) {
      x += y;
      return x >= mod ? x -= mod : x;
    }

    namespace pam {
    int sz, tot, last;
    int ch[MAXN][26], len[MAXN], fail[MAXN];
    int cnt[MAXN], dep[MAXN], dif[MAXN], slink[MAXN];
    char s[MAXN];

    int node(int l) {  // 建立一个长度为 l 的新节点
      sz++;
      memset(ch[sz], 0, sizeof(ch[sz]));
      len[sz] = l;
      fail[sz] = 0;
      cnt[sz] = 0;
      dep[sz] = 0;
      return sz;
    }

    void clear() {  // 初始化
      sz = -1;
      last = 0;
      s[tot = 0] = '$';
      node(0);
      node(-1);
      fail[0] = 1;
    }

    int getfail(int x) {  // 找到后缀回文
      while (s[tot - len[x] - 1] != s[tot]) x = fail[x];
      return x;
    }

    void insert(char c) {  // 建树
      s[++tot] = c;
      int now = getfail(last);
      if (!ch[now][c - 'a']) {
        int x = node(len[now] + 2);
        fail[x] = ch[getfail(fail[now])][c - 'a'];
        dep[x] = dep[fail[x]] + 1;
        ch[now][c - 'a'] = x;
        dif[x] = len[x] - len[fail[x]];
        if (dif[x] == dif[fail[x]])
          slink[x] = slink[fail[x]];
        else
          slink[x] = fail[x];
      }
      last = ch[now][c - 'a'];
      cnt[last]++;
    }
    }  // namespace pam

    using pam::dif;
    using pam::fail;
    using pam::len;
    using pam::slink;
    int n, dp[MAXN], g[MAXN];
    string s;
    char t[MAXN];

    int main() {
      cin.tie(nullptr)->sync_with_stdio(false);
      pam::clear();
      cin >> s;
      n = s.size();
      s = " " + s;
      for (int i = 1, j = 0; i <= n; i++) t[++j] = s[i], t[++j] = s[n - i + 1];
      dp[0] = 1;
      for (int i = 1; i <= n; i++) {
        pam::insert(t[i]);
        for (int x = pam::last; x > 1; x = slink[x]) {
          g[x] = dp[i - len[slink[x]] - dif[x]];
          if (dif[x] == dif[fail[x]]) g[x] = add(g[x], g[fail[x]]);
          if (i % 2 == 0) dp[i] = add(dp[i], g[x]);  // 在偶数位置更新 dp 数组
        }
      }
      cout << dp[n];
      return 0;
    }

## 例题

- 最长双回文串

- 拉拉队排练

- 「SHOI2011」双倍回文

- HDU 5421 Victor and String

- CodeChef Palindromeness

## 相关资料

- EERTREE: An Efficient Data Structure for Processing Palindromes in Strings

- Palindromic tree

- 2017 年 IOI 国家候选队论文集 回文树及其应用 翁文涛

- 2019 年 IOI 国家候选队论文集 子串周期查询问题的相关算法及其应用 陈孙立

- 字符串算法选讲 金策

- A bit more about palindromes

- A Subquadratic Algorithm for Minimum Palindromic Factorization

> 本页面最近更新：2026/1/7 08:56:54，更新历史
> 发现错误？想一起完善？ 在 GitHub 上编辑此页！
> 本页面贡献者：Ir1d, yjl9903, H-J-Granger, StudyingFather, countercurrent-time, NachtgeistW, Tiphereth-A, Early0v0, Enter-tainer, PotassiumWings, AngelKitty, CCXXXI, cjsoft, diauweb, ezoixx130, GekkaSaori, iamtwz, Konano, LovelyBuggies, Makkiy, mgt, minghu6, P-Y-Y, SamZhangQingChuan, sshwy, Suyun514, weiyong1024, aofall, CoelacanthusHex, GavinZhengOI, Gesrua, Henry-ZHR, huhaoo, kenlig, ksyx, kxccc, Leasier, lychees, Marcythm, ouuan, Peanut-Tang, Persdre, shuzhouliu, SukkaW, TOMWT-qwq, ZXyaang
> 本页面的全部内容在 CC BY-SA 4.0 和 SATA 协议之条款下提供，附加条款亦可能应用