BZOJ3676: [Apio2014]回文串

比较重要的结论：一个字符串内本质不同的回文串的级别是
O(n)的，因为manacher的时候每次暴力扩展出来的回文串才是新的回文串，最多扩展O(n)次。
所以我们可以对所有本质不同的回文串在后缀数组/后缀自动机上求一下出现了多少次即可…
注意注意注意manacher不要写错…>_<…
SA:
16112 ms

#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define ll long long
//by:MirrorGray
using namespace std;
const int N=611111;
int n,p[N];
char s[N];
int gs[N],wv[N],wb[N];
int K[N],dp[N][23],sa[N],rank[N],height[N];

bool cmp(int *x,int a,int b,int l){
    return x[a]==x[b]&&x[a+l]==x[b+l];
}

void da(int *sa,int *x,int n,int m){
    int i,j,p,*y=wb;
    for(i=0;i<m;i++)gs[i]=0;
    for(i=0;i<n;i++)gs[ x[i] ]++;
    for(i=1;i<m;i++)gs[i]+=gs[i-1];
    for(i=n-1;~i;i--)sa[ --gs[x[i]] ]=i;
    for(j=1,p=1;p<n;j<<=1,m=p){
        for(i=n-j,p=0;i<n;i++)y[p++]=i;
        for(i=0;i<n;i++)if(sa[i]>=j)y[p++]=sa[i]-j;
        for(i=0;i<n;i++)wv[i]=x[ y[i] ];
        for(i=0;i<m;i++)gs[i]=0;
        for(i=0;i<n;i++)gs[ wv[i] ]++;
        for(i=1;i<m;i++)gs[i]+=gs[i-1];
        for(i=n-1;~i;i--)sa[ --gs[wv[i]] ]=y[i];
        p=1;swap(x,y);x[ sa[0] ]=0;
        for(i=1;i<n;i++)x[ sa[i] ]=cmp(y,sa[i-1],sa[i],j)?p-1:p++;
    }
}

void calheight(int n){
    int i,j,k=0;
    for(i=0;i<=n;i++)rank[ sa[i] ]=i;
    for(i=0;i<n;height[ rank[i++] ]=k)
    for(k?k--:233,j=sa[ rank[i]-1 ];s[i+k]==s[j+k];k++);
    for(int i=1;i<=n;i++)dp[i][0]=height[i];
    for(int j=1; 1<<j <=n;j++)
    for(int i=1;i+(1<<j)-1<=n;i++)
    dp[i][j]=min(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);
    for(int i=1;i<=n;i++)K[i]=log2(i);
//  for(int i=0;i<=n;i++)cout<<sa[i]<<" "<<rank[i]<<" "<<height[i]<<endl;
//  for(int i=0;i<=n;i++)cout<<s+sa[i]<<endl;
}

int Q(int l,int r){
    if(l==r)return n-sa[l];
    if(l>r)swap(l,r);l++;
    int k=K[r-l+1];
    return min(dp[l][k],dp[r-(1<<k)+1][k]);
}

int findL(int x,int L){
    int l=1,r=x,ret=-1;
    while(l<=r){
        int mid=(l+r)>>1;
        if(Q(mid,x)>=L)r=mid-1,ret=mid;
        else l=mid+1;
    }
    return ret;
}

int findR(int x,int L){
    int l=x,r=n,ret=-1;
    while(l<=r){
        int mid=(l+r)>>1;
        if(Q(x,mid)>=L)l=mid+1,ret=mid;
        else r=mid-1;
    }
    return ret;
}

void manacher(int n){
    ll ans=0;
    for(int i=n-1;~i;i--)s[i*2+1]=s[i],s[i*2+2]='^';
    s[0]='^';n<<=1;
    int id=1,mx=1;
    for(int i=1;i<=n;i++){
        p[i]=min(p[2*id-i],mx-i);
        while(i-p[i]>=0 && s[i-p[i]]==s[i+p[i]]){
            int al=(i-p[i])/2,ar=(i+p[i]-1)/2;
            int l=findL(rank[al],ar-al+1),r=findR(rank[al],ar-al+1);
            ans=max(ans,(ll)(r-l+1)*(ar-al+1));
            p[i]++;
        }
        if(p[i]+i>mx)mx=p[i]+i,id=i;
    }
    printf("%lld\n",ans);
}

int main(){
    scanf("%s",s);n=strlen(s);
    for(int i=0;i<n;i++)rank[i]=s[i];
    da(sa,rank,n+1,256);calheight(n);
    manacher(n); 
    return 0;
}

SAM是快…可是太容易mle了啊…>_<…
10412 ms
SAM：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define ll long long
//by:MirrorGray
using namespace std;
const int N=611111;
char s[N];
int n,last,root,cnt;
int p[N],pos[N],gs[N],q[N],fa[N][21];
struct SAM{
    int nxt[26],fa,mx,s;
}tr[N];

int nwn(int l){
    tr[++cnt].mx=l;
    return cnt;
}

int extend(int x){
    int np=nwn(tr[last].mx+1);tr[np].s=1;
    int p=last;last=np;
    for(;p && !tr[p].nxt[x];p=tr[p].fa)tr[p].nxt[x]=np;
    if(!p)return tr[np].fa=root,233;
    int q=tr[p].nxt[x];
    if(tr[q].mx==tr[p].mx+1)return tr[np].fa=q,233;
    int nq=nwn(tr[p].mx+1);
    tr[nq].fa=tr[q].fa;tr[q].fa=tr[np].fa=nq;
    memcpy(tr[nq].nxt,tr[q].nxt,sizeof(tr[q].nxt));
    for(;p && tr[p].nxt[x]==q;p=tr[p].fa)tr[p].nxt[x]=nq;
}

void toposort(){
    for(int i=1;i<=n;i++)gs[i]=0;
    for(int i=1;i<=cnt;i++)gs[ tr[i].mx ]++;
    for(int i=1;i<=n;i++)gs[i]+=gs[i-1];
    for(int i=cnt;i;i--)q[ gs[tr[i].mx]-- ]=i;
    for(int i=cnt;i;i--)tr[ tr[q[i]].fa ].s+=tr[ q[i] ].s;//在parent tree上… 
    memset(fa,-1,sizeof(fa));
    for(int i=1;i<=cnt;i++)fa[i][0]=tr[i].fa;
    for(int j=1; 1<<j <=n;j++)
    for(int i=1;i+(1<<j)<=n;i++)
    if(~fa[i][j-1])fa[i][j]=fa[ fa[i][j-1] ][j-1];
}

ll Q(int x,int l){
    for(int i=20;~i;i--)if(~fa[x][i] && tr[ fa[x][i] ].mx>=l)x=fa[x][i];
    return tr[x].s;
}

void manacher(int n){
    for(int i=n;i;i--)s[i*2-1]=s[i],s[i*2]='^';
    s[0]='^';n<<=1;
    ll ans=0;int mx=1,id=1;
    for(int i=1;i<=n;i++){
        p[i]=min(p[2*id-i],mx-i);
        while(i-p[i]>0 && s[i-p[i]]==s[i+p[i]]){
            int al=(i-p[i])/2+1,ar=(i+p[i]+1)/2;
//          cout<<al<<" "<<ar<<endl;
            ans=max(ans,(ar-al+1)*Q(pos[ar],ar-al+1));
            p[i]++;
        }
        if(i+p[i]>mx)id=i,mx=i+p[i];
    }
    printf("%lld\n",ans);
}

int main(){
    scanf("%s",s+1);n=strlen(s+1);
    root=last=nwn(0);
    for(int i=1;s[i];i++)pos[i]=cnt+1,extend(s[i]-'a');
    toposort();
    manacher(n);
    return 0;
}

PAM:（是优越啊毕竟o(n)）
812 ms

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define ll long long
//by:MirrorGray
using namespace std;
const int N=311111;
char s[N];
int cnt,n,last;
struct PAM{
    int nxt[26],f,cnt,l;
}tr[N];

int nwn(int l){
    tr[++cnt].l=l;
    return cnt;
}

int fail(int x){
    while(s[n-tr[x].l-1]!=s[n])x=tr[x].f;
    return x;
}

void extend(int x){
    int p=fail(last);
    if(!tr[p].nxt[x]){
        int t=nwn(tr[p].l+2);
        tr[t].f=tr[ fail(tr[p].f) ].nxt[x];
        tr[p].nxt[x]=t;
    }
    last=tr[p].nxt[x];
    tr[last].cnt++;
}

ll calc(){
    ll ret=0;
    for(int i=cnt;i;i--)tr[ tr[i].f ].cnt+=tr[i].cnt;
    for(int i=2;i<=cnt;i++)ret=max(ret,(ll)tr[i].cnt*tr[i].l);
    return ret;
}

int main(){
    tr[0].f=1;tr[cnt=1].l=-1;
    scanf("%s",s+1);s[0]=-1;
    for(int i=1;s[i];i++)n=i,extend(s[i]-'a');
    printf("%lld\n",calc());
    return 0;
}