2019牛客暑期多校训练营（第六场）C：Palindrome Mouse（回文树+树剖）

题意：给定字符串Str，求出回文串集合为S，问S中的(a,b)满足a是b的子串的对数。

思路：开始和题解的思路差不多，维护当前后缀的每个串的最后出现位置，但是不知道怎么套“最小回文分割”，所以想到了树剖，但是树剖不好同时维护“最后出现的次数”，“查询左端点>=L”的位置数。   所以GG。  那么从图论的角度考虑，有向图，问多少个点可以到达的关系点对，（我怎么只会bitset解决小数据问题）。

1，而回文树的特殊性在于，每个点只有一个fail(回边)，25个next(出边)，那么把回边抽离出来建立fail树。那么就是顺着next可以得到答案，问题是要去重。

去重的过程可以加一个vis数组标记即可。  这种有向图，DFS可做。

2，这里为了和比赛的时候想法接近一下，是用树剖实现的。  fail树上树剖，next指针搜索，每次把当前点的fail链标记量++；  回溯的时候标记量--；由于都是先加后删，所以没必要下推tag，这样反而保证了复杂度。

#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=a;i<=b;i++)
using namespace std;
const int maxn=;
int tot;  struct PAT
{
    struct node{
        int len,num,fail,son[];
    }t[maxn];
    int last,n,s[maxn];
    void init()
    {
        memset(t,,sizeof(t));
        tot=last=; n=;
        t[].len=; t[].len=-;
        t[].fail=t[].fail=;
        s[]=-;
    }
    int add(int c){
        int p=last; s[++n]=c;
        while(s[n]!=s[n--t[p].len]) p=t[p].fail;
        if(!t[p].son[c]){
            int v=++tot,k=t[p].fail;
            while(s[n]!=s[n-t[k].len-]) k=t[k].fail;
            t[v].fail=t[k].son[c];
            t[v].len=t[p].len+;
            t[v].num=t[t[v].fail].num+;
            t[p].son[c]=v;
        }
        last=t[p].son[c];
        return t[last].num;
    }
}T;
char c[maxn];
int Laxt[maxn],Next[maxn],To[maxn],cnt;
int son[maxn],Top[maxn],fa[maxn],pos[maxn],times;
int tag[maxn<<],sum[maxn<<],sz[maxn];
void Add(int u,int v)
{
    Next[++cnt]=Laxt[u]; Laxt[u]=cnt; To[cnt]=v;
}
void dfs1(int u,int f)
{
    sz[u]=; son[u]=; fa[u]=f;
    for(int i=Laxt[u];i;i=Next[i]){
        if(To[i]!=f){
            dfs1(To[i],u);
            sz[u]+=sz[To[i]];
            if(sz[To[i]]>sz[son[u]]) son[u]=To[i];
        }
    }
}
void dfs2(int u,int tp)
{
    Top[u]=tp; pos[u]=++times;
    if(son[u]) dfs2(son[u],tp);
    for(int i=Laxt[u];i;i=Next[i]){
        if(To[i]==son[u]) continue;
        dfs2(To[i],To[i]);
    }
}
void pushup(int Now,int L,int R)
{
    if(tag[Now]) sum[Now]=R-L+;
    else if(L==R) sum[Now]=;
    else sum[Now]=sum[Now<<]+sum[Now<<|];
}
void add(int Now,int L,int R,int l,int r,int x)
{
    if(l<=L&&r>=R) {
        tag[Now]+=x;
        pushup(Now,L,R);
        return ;
    }
    int Mid=(L+R)>>;
    if(l<=Mid) add(Now<<,L,Mid,l,r,x);
    if(r>Mid) add(Now<<|,Mid+,R,l,r,x);
    pushup(Now,L,R);
}
int query(int Now,int L,int R,int l,int r)
{
    if(l<=L&&r>=R){
        if(tag[Now]) return R-L+;
        if(L==R) return ;
        return sum[Now<<]+sum[Now<<|];
    }
    int res=,Mid=(L+R)>>;
    if(l<=Mid) res+=query(Now<<,L,Mid,l,r);
    if(r>Mid) res+=query(Now<<|,Mid+,R,l,r);
    pushup(Now,L,R);
    return res;
}
void ADD(int p,int x)
{
    while(Top[p]!=) {
        add(,,tot,pos[Top[p]],pos[p],x);
        p=T.t[Top[p]].fail;
    }
    if(p!=) add(,,tot,,pos[p],x);
}
long long ans;
void solve(int u)
{
    if(u>) ADD(u,),ans+=sum[]-;
    rep(i,,)
      if(T.t[u].son[i])
        solve(T.t[u].son[i]);
    if(u>) ADD(u,-);
}
int main()
{
    int TT,C=,N;
    scanf("%d",&TT);
    while(TT--){
        T.init(); ans=; times=;
        scanf("%s",c+); N=strlen(c+);
        rep(i,,N) T.add(c[i]-'a');
        rep(i,,tot) Laxt[i]=; cnt=;
        rep(i,,tot) {
            if(T.t[i].fail==) T.t[i].fail=;
            Add(T.t[i].fail,i);
        }
        dfs1(,); dfs2(,);
        solve();
        solve();
        printf("Case #%d: %lld\n",++C,ans);
    }
    return ;
}