[BZOJ3676][Apio2014]回文串-后缀自动机+Manacher | | 回文树

[Apio2014]回文串

Description

考虑一个只包含小写拉丁字母的字符串s。我们定义s的一个子串t的“出现值”为t在s中的出现次数乘以t的长度。请你求出s的所有回文子串中的最大出现值。

Input

输入只有一行，为一个只包含小写字母(a -z)的非空字符串s。

Output

输出一个整数，为逝查回文子串的最大出现值。

Sample Input

【样例输入l】
abacaba

【样例输入2]
www

Sample Output

【样例输出l】
7

【样例输出2]
4

HINT

一个串是回文的，当且仅当它从左到右读和从右到左读完全一样。

在第一个样例中，回文子串有7个：a，b，c，aba，aca，bacab，abacaba，其中：

● a出现4次，其出现值为4：1：1=4
● b出现2次，其出现值为2：1：1=2
● c出现1次，其出现值为l：1：l=l
● aba出现2次，其出现值为2：1：3=6
● aca出现1次，其出现值为1=1：3=3
● bacab出现1次，其出现值为1：1：5=5
● abacaba出现1次，其出现值为1：1：7=7

故最大回文子串出现值为7。

【数据规模与评分】

数据满足1≤字符串长度≤300000。

---

交了20+次，从TLE到WA再到RE，跨越了整整一天……

(╯‵□′)╯︵┻━┻

---

思路:
参考了某学长,用后缀自动机+马拉车 Manacher来实现……
大概是用Manacher尽量找出本质不同的回文串进行询问可以减少询问次数~
然后用后缀自动机求出现次数，就可以了~

然而看了思路后随手往下一翻——
学长你这真的是Manacher？？
我怀疑我学了假的Manacher……

然后就是Manacher写炸了T了好久，接着是调Manacher的时候把其他部分也调错了WA了好久，最后各种迷之小错RE半天……(╯‵□′)╯︵┻━┻

实现上，能更新MaxRight的回文串就(极有可能)是本质不同的回文串~
其起点和终点在后缀自动机上的fa树上的公共祖先的right集合大小即是出现次数~

---

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;

typedef long long ll;

const int N=300010;

char s[N],ch[N<<1];
int n,p[N<<1],bin[40];
ll ans;

struct SAM
{
    int next[N<<1][26],fa[N<<1],dep[N<<1];
    int len[N<<1],siz[N<<1],a[N<<1][20];
    int b[N],id[N<<1],pos[N];
    int u,pool;

    SAM()
    {
        u=pool=1;
    }

    inline void add(int v)
    {
        int now=++pool;
        len[now]=len[u]+1;
        siz[now]=1;

        while(u && !next[u][v])
            next[u][v]=now,u=fa[u];

        if(!u)
            fa[now]=1;
        else
        {
            int q=next[u][v];
            if(len[q]==len[u]+1)
                fa[now]=q;
            else
            {
                int newq=++pool;
                memcpy(next[newq],next[q],sizeof(next[q]));
                len[newq]=len[u]+1;
                fa[newq]=fa[q];

                fa[q]=fa[now]=newq;

                while(next[u][v]==q)
                    next[u][v]=newq,u=fa[u];
            }
        }
        u=now;
    }

    inline void pre()
    {
        for(int i=1;i<=pool;i++)
            b[len[i]]++;
        for(int i=1;i<=n;i++)
            b[i]+=b[i-1];
        for(int i=pool;i>=1;i--)
            id[b[len[i]]--]=i;
        for(int i=pool;i>=1;i--)
            siz[fa[id[i]]]+=siz[id[i]];

        siz[1]=0;
        for(int i=1;i<=pool;i++)
        {
            a[id[i]][0]=fa[id[i]];
            dep[id[i]]=dep[fa[id[i]]]+1;

            for(int j=1;bin[j]<=dep[id[i]];j++)
                a[id[i]][j]=a[a[id[i]][j-1]][j-1];
        }
    }

    inline long long query(int l,int mid)
    {
        int lens=(l-1)>>1;
        for(int i=18;i>=0;i--)
            if(len[a[mid][i]]>=lens)
                mid=a[mid][i];

        return (ll)siz[mid]*lens;
    }
}koishi;

inline void init()
{
    bin[0]=1;
    for(int i=1;i<=24;i++)
        bin[i]=bin[i-1]<<1;
}

int main()
{
    scanf("%s",s);
    n=strlen(s);

    init();
    for(int i=0;i<n;i++)
    {
        koishi.pos[i]=koishi.pool+1;
        koishi.add(s[i]-'a');
    }

    koishi.pre();

    for(int i=0;i<=2*n;i++)
        ch[i]='%';
    for(int i=0;i<n;i++)
        ch[(i<<1)|1]=s[i];

    int mx=0,md=0;
    p[0]=1;
    for(int i=1;i<=2*n;i++)
    {
        if(i<=mx)
            p[i]=min(p[2*md-i],mx-i+1);

        while(i-p[i]>=0 && i+p[i]<=2*n && ch[i+p[i]]==ch[i-p[i]])
        {
            p[i]++;
            if(ch[i+p[i]-1]!='%')
                continue;

            ans=max(ans,koishi.query(p[i]*2-1,koishi.pos[(i+p[i]-3)>>1]));
        }

        if(i+p[i]-1>mx)
            mx=i+p[i]-1,md=i;
    }

    printf("%lld\n",ans);

    return 0;
}

---

写完本博客2小时后的更新:
咱去学了个回文树，然后就发现这题是裸题……
然后就写了一棵回文树……
然后一遍就过了，空间是之前的四分之一，时间四分之三……
咱™还能说些什么呢?
之前选择后缀自动机的咱简直太⑨了……

(╯‵□′)╯︵┻━┻

思路:
咱™就是在模板上加了一步统计答案……

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>

using namespace std;

const int N=300233;

struct PAM
{
    int next[N][26],len[N];
    int siz[N],fa[N];
    int s[N],u,top,pool;

    void init()
    {
        memset(next,0,sizeof(next));
        memset(len,0,sizeof(len));
        memset(siz,0,sizeof(siz));
        memset(fa,0,sizeof(fa));
        memset(s,0,sizeof(s));

        pool=1;
        len[1]=-1;
        u=top=0;
        fa[0]=fa[1]=1;
        s[0]=-1;
    }

    PAM()
    {
        init();
    }

    inline int getfa(int x)
    {
        while(s[top-len[x]-1]!=s[top])
            x=fa[x];
        return x;
    }

    inline void add(int v)
    {
        s[++top]=v;
        int last=getfa(u);

        if(!next[last][v])
        {
            int now=++pool;
            len[now]=len[last]+2;
            fa[now]=next[getfa(fa[last])][v];

            next[last][v]=now;
        }

        u=next[last][v];
        siz[u]++;
    }

    inline long long calc()
    {
        long long ans=0;
        for(int i=pool;i;i--)
        {
            siz[fa[i]]+=siz[i];
            ans=max(ans,(long long)siz[i]*len[i]);
        }
        return ans;
    }
}koishi;

int main()
{
    char ch[N];
    scanf("%s",ch+1);
    int len=strlen(ch+1);

    for(int i=1;i<=len;i++)
        koishi.add(ch[i]-'a');

    printf("%lld\n",koishi.calc());

    return 0;
}