BZOJ3676:[APIO2014]回文串(SAM,Manacher)

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。

Solution

垃圾题目卡$SAM+Manacher$做法的空间……害我把所有的结构体全拆开还把$SAM$的$son$数组换成了$map$才过……

首先众所周知，一个串的本质不同的回文子串只有$O(n)$级别，且在$Manacher$过程中右端点右移的情况就是本质不同的回文子串。所以我们可以做一遍$Manacher$把本质不同的回文子串求出来。

假设现在的一个回文子串是$S_{l,r}$，设$SAM$插入$r$的时候的$np$节点为$node_r$，那么我们知道，$S_{l,r}$一定是$node_r$代表的子串的一个后缀，且$S_{l,r}$的出现次数是$right_{node_r}$。

我们可以倍增从$node_r$往上跳，因为越往上跳$right$越大。跳到长度取值范围包括$r-l+1$的节点然后更新答案就可以了。

Code

 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<map>
 #define N (600009)
 #define LL long long
 using namespace std;

 int to[N],nxt[N];
 int n,m,pos[N],len[N];
 int Depth[N],f[N][];
 int head[N],num_edge;
 int p,q,np,nq,last=,cnt=;
 int fa[N],rig[N],step[N],node[N];
 map<int,int>son[N];
 LL ans;
 char s[N>>],t[N];

 void add(int u,int v)
 {
     to[++num_edge]=v;
     nxt[num_edge]=head[u];
     head[u]=num_edge;
 }

 void Insert(int x)
 {
     p=last; np=last=++cnt; step[np]=step[p]+; rig[np]=;
     while (!son[p][x] && p) son[p][x]=np, p=fa[p];
     if (!p) fa[np]=;
     else
     {
         q=son[p][x];
         if (step[q]==step[p]+) fa[np]=q;
         else
         {
             nq=++cnt; step[nq]=step[p]+;
             son[nq]=son[q];
             fa[nq]=fa[q]; fa[q]=fa[np]=nq;
             while (son[p][x]==q) son[p][x]=nq, p=fa[p];
         }
     }
 }

 void DFS(int x,int fa)
 {
     Depth[x]=Depth[fa]+; f[x][]=fa;
     for (int i=; i<=; ++i) f[x][i]=f[f[x][i-]][i-];
     for (int i=head[x]; i; i=nxt[i])
         DFS(to[i],x), rig[x]+=rig[to[i]];
 }

 void Calc()
 {
     for (int i=; i<n; ++i) Insert(s[i]-'a'), node[i]=np;
     for (int i=; i<=cnt; ++i) add(fa[i],i);
     DFS(,);
 }

 void Solve(int p,int k)
 {
     while (t[p+k]=='#' || t[p+k]==')') --k;
     int x=node[pos[p+k]],y=pos[p+k]-pos[p-k]+;
     for (int i=; i>=; --i) if (step[f[x][i]]>=y) x=f[x][i];
     ans=max(ans,1ll*rig[x]*y);
 }

 void Manacher()
 {
     t[++m]='(';
     for (int i=; i<n; ++i) t[++m]='#', t[++m]=s[i], pos[m]=i;
     t[++m]='#'; t[++m]=')';

     int x,mid=,maxn=;
     for (int i=; i<=m; ++i)
     {
         if (i>maxn) x=;
         else x=min(maxn-i+,len[mid*-i]);
         while (t[i+x]==t[i-x]) Solve(i,x), ++x;
         len[i]=x;
         if (i+x->maxn) maxn=i+x-, mid=i;
     }
 }

 int main()
 {
     scanf("%s",s); n=strlen(s);
     Calc(); Manacher();
     printf("%lld\n",ans);
 }