​​ACM-ICPC 2018 南京赛区网络预赛 I. Skr​​

回文自动机

​​javascript:void(0)​​ 回文自动机是针对一个字符串建的树。他有下面作用：

1.求串S前缀0~i内本质不同回文串的个数（两个串长度不同或者长度相同且至少有一个字符不同便是本质不同）

2.求串S内每一个本质不同回文串出现的次数

3.求串S内回文串的个数（其实就是1和2结合起来）

4.求以下标i结尾的回文串的个数

实际上，回文自动机的实质就是按顺序添加字符，每添加一个字符都要找出以这个字符为后缀的最长的回文串，方法就是在以前一个为后缀的所有回文串中找到一个可以和这个点匹配的，然后再加入到树中。
注意区分一下“字符”和“节点”的概念，一个字符就是字符串中的一个字符，而回文自动机当中的节点表示了一个字符串。

题目

例题里，给一个 2e6字符串，全是 1-9，问所有回文子串相加多少。

分析

对给出的串 S 建回文树，根据回文树的定义，分别从偶根 和 奇根遍历两颗树的每一个节点，也就是每一个本质不同的回文串，按题目意思相加即可。

#include <bits/stdc++.h>
using namespace std;
#define ll long long 
#define INF 0x3f3f3f3f
const int N = 2e6 + 10;
const int M = 1e2 + 5;
const int ALP = 10;         // 字符集大小
const ll mod = 1e9 + 7;

ll _pow(ll x, ll y){
    ll res = 1; x %= mod;
    while(y){
        if(y&1) res = res * x % mod;
        x = x * x % mod;
        y >>= 1;
    }
    return res;
}

struct PAM{
    int next[N][ALP];  // next指针,指向的串为当前串两端加上同一个字符构成
    int fail[N];    // fail指针，失配后跳的地方
    int len[N];     // i 结点回文串的长度
    int s[N];       // 添加的字符
    int last, n, p; // 上一个结点，字符个数，结点个数
    ll ans;
    
    int newnode(int l) {
        for (int i = 0; i < 10; i++) 
            next[p][i] = 0;
        len[p] = l;
        return p++;
    }
    void init(){
        ans = p = 0;
        newnode(0);     // 偶跟
        newnode(-1);    // 奇根
        last = n = 0;
        s[n] = -1;      //开头放一个字符集中没有的字符，减少特判
        fail[0] = 1;    
    }
    int get_fail(int x){    // 失配后找尽量最长的
        while(s[n-len[x]-1] != s[n]) x = fail[x];
        return x;
    }
    void add(int c){
        c -= '0';
        s[++n] = c;
        int cur = get_fail(last);   //通过上一个回文串找这个回文串的匹配位置
        if(!next[cur][c]){      //如果这个回文串没有出现过，说明出现了一个新的本质不同的回文串
            int now = newnode( len[cur] + 2 ); // 新建节点
            fail[now] = next[get_fail(fail[cur])][c]; //建立fail 指针
            next[cur][c] = now;
        }
        last = next[cur][c];
    }   
    void dfs(int rt, ll s, int len){
        for(int i = 0; i < 10; i++){
            if(next[rt][i]){
                ll ts = s;
                int tlen = len;
                if(rt == 0){     // 在偶根
                    ts = i * 10 + i;
                    tlen += 2;
                }else if(rt == 1){  // 奇根
                    ts = i;
                    tlen++;
                }else {
                    ts = (ts + i*_pow(10, tlen) % mod) % mod;
                    ts = (ts * 10 % mod + i) % mod;
                    tlen += 2;
                }
                ans = (ans + ts) % mod;
                dfs(next[rt][i], ts, tlen);
            }
        }
    }

}pam;

char s[N];

int main(){
    pam.init();
    scanf("%s", s);
    int len = strlen(s);
    for(int i = 0; i < len; i++){
        pam.add(s[i]);
    }
    pam.dfs(0, 0, 0);   // 偶根
    pam.dfs(1, 0, 0);   // 奇根
    printf("%lld\n", pam.ans);
    return  0;
}
/*
5 4
3 10 5 2 7
8
1 2 3 4 5 6 7 8
 */