回文树（回文自动机）- 笔记

回文树详解1：What Is Palindromic auto-machine?：回文自动机，又叫回文树，是由俄罗斯人 MikhailRubinchik于2014年夏发明的(http://codeforces.com/blog/entry/13959).

这是一种比较新的数据结构，在原文中已有详细介绍与代码实现。

回文树其实不是严格的树形结构，因为它有是两棵树，分别是偶数长度的回文树和奇数长度的回文树，树中每个节点代表一个回文串。

为了方便，第一棵树的根是一个长度为0的串，第二棵就是为-1的串，不要感到奇怪，就是-1。

可以证明，最多只有n个结点（n是串的长度）。这个可以用Manacher算法来证明。

如果某结点代表的是串ccabacc，那么它的父亲代表的串就是去掉前后两个字符cabac。

每个点还有一个fail指针，表示这个串的后缀中最长的回文串，比如babab的fail指向bab，bab的指向b。

方法的思想和KMP，AC自动机很类似
回文树详解2：回文树介绍(Palindromic Tree)
题解 P5496 【【模板】回文自动机（PAM）】：里面有fail数组的含义解释，和，借助trans数组解双倍回文

---

首先，如上面说到的，树中每个节点代表一个回文串，那么由字符串“abbaabba”得到的回文树结构大概是这个样子：（红色是结点编号，节点里面是 结点所代表的的回文串 及其长度）

1、计算本质不同的回文串个数

像AC自动机一样，我们需要通过一个数组next[ ][ ]来存回文树的结构。next[i][j]表示在结点i表示的回文串前后加一个字符‘j’ 得到的新的回文串编号

每个点的fail指针，表示它的后缀中最长的回文串的编号。实际上我们可以通过fail数组遍历到以这个点结尾的所有的后缀回文串。知道这一点，我们就可以计算串S内回文串的个数了

我们用一个last记录以上一个结点结尾的最长回文串的编号，当我们新加入一个结点时，我们就可以通过上一个结点的fail找到以当前结点结尾的最长回文串，然后判断这个回文串是否已经存在，不存在就新建一个结点来存它。然后继续遍历上一个结点的fail找到当前结点的fail（这段的详细说明可以看上面详解2中回文串构造部分）
//刚看完回文树的时候一直有点迷为什么只用找一次fail就可以知道以当前结点结尾的所有回文串的信息，还有为什么加入结点的过程中cnt数组记录的次数是不完整的，所以过了几天才来补这篇博客hhh。//如下图1，红色表示的回文串是这个最长回文串的fail，即它的最长后缀回文串，实际上如图2这个回文串的信息在前面已经处理过了，所以我们只用将fail“指针”指向这个回文串，就可以遍历到所有后缀回文串了

明白这些，我们就可以解决最基本的问题：计算字符串中本质不同的回文串个数，也就是回文树结点个数p减去两个根结点——p-2

struct pal_tree
{
    int net[manx][26];//next指针，指向的串为当前串两端加上同一个字符构成
    int fail[manx];//fail指针，失配后跳转到fail指针指向的节点
    int S[manx];//存放添加的字符
    int len[manx];//len[i]表示节点i表示的回文串的长度
    int last ;//指向以上一个字符结尾的最长后缀回文串，方便下一次add
    int n ;//字符数组指针
    int p ;//节点指针
    int newnode(int l)//新建节点
    {
        for(int i=0;i<26;i++)
            net[p][i]=0;
        len[p]=l;
        return p++;
    }
    void init()//初始化
    {
        p=n=0;
        newnode(0);
        newnode(-1);
        fail[0]=1;//可以不用给fail[1]赋值
        last=0;
        S[n]=-1;//开头放一个字符集中没有的字符，省略每次去判断是否越界
    }
    int getfail(int x)//和KMP一样，失配后找一个尽量最长的
    {
        while(S[n-len[x]-1]!=S[n])x=fail[x];
        return x;
    }
    void add(int c)
    {
        c-='a';
        S[++n]=c;
        int cur=getfail(last);//通过上一个回文串找这个回文串的匹配位置
        if(!net[cur][c])//如果这个回文串没有出现过，说明出现了一个新的本质不同的回文串
        {
            int now=newnode(len[cur]+2);
            fail[now]=net[getfail(fail[cur])][c];//和AC自动机一样建立fail指针，以便失配后跳转
            net[cur][c]=now;//找到fail[now]后，将新节点now存在net[cur][c]中
        }
        last=net[cur][c];
        //cnt[last]++;
    }
}tree;
int main()
{
    scanf("%s",s);
    tree.init();
    for(int i=0; s[i]!='\0'; i++)
        tree.add(s[i]);
    printf("%d\n",tree.p-2);
    return 0;
}
//部分注释来自回文串详解1

2、计算串S内回文串的个数

既然我们可以通过fail数组遍历到以这个点结尾的所有的后缀回文串，那么就可以用一个数组num[ ]记录每个结点的fail数组的“深度”，这个“深度”也就是以这个结点结尾的回文串个数

3、计算串S内每一个本质不同回文串出现的次数

类似tire树中的vs数组，cnt数组只是将“以当前结点结尾的最长回文串”出现的次数上+1了，见上文代码中倒数第三行的注释。所以它的fail链前面的结点，即以当前结点结尾的其他回文串还没有统计，所以最后还要处理一遍cnt数组：

void ccount()
{
    for(int i=p-1; i>1; i--)
        cnt[fail[i]]+=cnt[i];
}

4、整体实现

#include <stdio.h>
#include <math.h>
#include <string.h>
#include <algorithm>
#include <iostream>
#include <queue>
using namespace std;
#define int long long
const int manx=3e5+10;
const int max_len=2e6+10;
char s[manx];
int ans=0;
struct pal_tree
{
    int net[manx][26],fail[manx],S[manx],len[manx]；
    int num[manx];//当前节点通过fail指针到达0节点或1节点的步数(fail指针的深度)
    int cnt[manx];//记录每个回文串出现的次数
    int p,last,n;
    int newnode(int l)
    {
        for(int i=0;i<26;i++)
            net[p][i]=0;
        cnt[p]=num[p]=0;//新增1
        len[p]=l;
        return p++;
    }
    void init()
    {
        p=n=0;
        newnode(0);
        newnode(-1);
        fail[0]=1;//可以不用给fail[1]赋值
        last=0;
        S[n]=-1;
    }
    int getfail(int x)
    {
        while(S[n-len[x]-1]!=S[n])x=fail[x];
        return x;
    }
    void add(int c)
    {
        c-='a';
        S[++n]=c;
        int cur=getfail(last);
        if(!net[cur][c])
        {
            int now=newnode(len[cur]+2);
            fail[now]=net[getfail(fail[cur])][c];
            net[cur][c]=now;
            num[now]=num[fail[now]]+1;//新增2
        }
        last=net[cur][c];
        cnt[last]++;//新增3
    }
    void ccount()//新增4
    {
        for(int i=p-1;i>1;i--)
        {
            //ans=max(ans,len[i]*cnt[i]);
            cnt[fail[i]]+=cnt[i];
        }
    }
}tree;
signed main()
{
    scanf("%s",s);
    tree.init();
    for(int i=0;s[i]!='\0';i++)
        tree.add(s[i]);
    tree.ccount();
    //printf("%lld\n",ans);
    return 0;
}