【BZOJ 3676】 3676: [Apio2014]回文串 （SAM+Manacher+倍增）

3676: [Apio2014]回文串

Time Limit: 20 Sec  Memory Limit: 128 MB
Submit: 2343  Solved: 1031

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。

Source

【分析】

　　听说回文自动机可以秒掉这题，以后再学吧。

　　用串建SAM，然后求出right数组。

　　manacher告诉我们，本质不同的回文串最多n个，只有在mx变的时候可能增加一个回文串。

　　用manacher求出所有本质不同的回文串，然后在SAM上问。

　　那就是问[L,R]这个区间的子串出现了多少次【感觉这个用后缀数组的话是nlogn^2的

　　从SAM的pre边相当于AC自动机上的fail，形成一棵树，pre树上倍增即可。

　　就是从POS[R]开始跳，当他代表的子串的长度大于r-l+1，即可计入答案，当然子串长度越小越好（更有可能出现最多次）

　　【记得拓扑序

　　【啊。。。卡空间。。

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#define Maxn 301000
#define LL long long

// int mymax(int x,int y) {return x>y?x:y;}
LL mymax(LL x,LL y) {return x>y?x:y;}
int mymin(int x,int y) {return x<y?x:y;}

LL ans=0;

struct node
{
    int pre,step,son[30],rt;
}t[2*Maxn];int last,tot;
int v[2*Maxn],q[2*Maxn],pos[2*Maxn];

int ff[2*Maxn][19];
void get_f()
{
    for(int i=1;i<=tot;i++) ff[i][0]=t[i].pre;
    for(int i=1;i<=tot;i++)
    {
       int nw=q[i];
       for(int j=1;j<=18;j++)
        ff[nw][j]=ff[ff[nw][j-1]][j-1];
    }
}

int now;
struct sam
{
    void extend(int k)
    {
        int np=++tot,p=last;
        t[np].step=t[last].step+1;
        t[np].rt=1;pos[++now]=np;
        while(p&&!t[p].son[k])
        {
            t[p].son[k]=np;
            p=t[p].pre;
        }
        if(!p) t[np].pre=1;
        else
        {
            int q=t[p].son[k];
            if(t[q].step==t[p].step+1) t[np].pre=q;
            else
            {
                int nq=++tot;
                memcpy(t[nq].son,t[q].son,sizeof(t[nq].son));
                t[nq].step=t[p].step+1;
                t[nq].pre=t[q].pre;
                t[q].pre=t[np].pre=nq;
                while(p&&t[p].son[k]==q)
                {
                    t[p].son[k]=nq;
                    p=t[p].pre;
                }
            }
        }
        last=np;
    }
    void init()
    {
        memset(v,0,sizeof(v));
        for(int i=1;i<=tot;i++) v[t[i].step]++;
        for(int i=1;i<=tot;i++) v[i]+=v[i-1];
        for(int i=tot;i>=1;i--) q[v[t[i].step]--]=i;
        
        for(int i=tot;i>=1;i--)
        {
            int nw=q[i];
            t[t[nw].pre].rt+=t[nw].rt;
        }
    }
    void ffind(int l,int r)
    {
        l=l/2+1;r=(r+1)/2;
        int x=pos[r];
        for(int i=18;i>=0;i--)
        {
            if(t[ff[x][i]].step>=r-l+1) x=ff[x][i];
        }
        ans=mymax(ans,1LL*(r-l+1)*t[x].rt);
    }
}sam;

char s[Maxn];
// int a[2*Maxn],p[2*Maxn];

void manacher(int l)
{
    v[0]=99;
    for(int i=0;i<l;i++) v[2*i+1]=s[i]-'a'+1,v[2*i+2]=99;
    v[2*l+1]=110;
    l=2*l;
    int mx=0,id=0;
    for(int i=1;i<=l;i++)
    {
        if(i<mx) q[i]=mymin(mx-i+1,q[2*id-i]);
        else q[i]=1;
        while(v[i+q[i]]==v[i-q[i]]&&i-q[i]>=0)
        {
            q[i]++;
            sam.ffind(i-q[i]+1,i+q[i]-1);
        }
        if(i+q[i]-1>mx) mx=i+q[i]-1,id=i;
    }
}

int main()
{
    scanf("%s",s);
    int l=strlen(s);
    last=tot=1;now=0;
    for(int i=0;i<l;i++) sam.extend(s[i]-'a'+1);
    sam.init();
    get_f();
    manacher(l);
    printf("%lld
",ans);
    return 0;
}

2017-04-17 16:54:09