HDU 3068 最长回文

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=3068

最长回文

Time Limit: 4000/2000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 8840    Accepted Submission(s): 3042

Problem Description

给出一个只由小写英文字符a,b,c...y,z组成的字符串S,求S中最长回文串的长度.
回文就是正反读都是一样的字符串,如aba, abba等

 

Input

输入有多组case,不超过120组,每组输入为一行小写英文字符a,b,c...y,z组成的字符串S
两组case之间由空行隔开(该空行不用处理)
字符串长度len <= 110000

 

Output

每一行一个整数x,对应一组case,表示该组case的字符串中所包含的最长回文长度.

 

Sample Input

  
  

   
   aaaa

abab
  
  

 

Sample Output

  
  

   
   4
3
  
  

 如果不考虑求回文子串的复杂度，那可选算法颇多。

1.直接暴力枚举，枚举所有子串的复杂度为O(n^2)，每个子串判断是否回文的复杂度为O(n)，总复杂度为O（n^3）

2.动态规划，利用中心点向两边扩散，避免了一些不必要的重复计算，复杂度为O(n^2)

上面两种算法较为简单，我就不给出代码了。

3.后缀数组,创建后缀数组的复杂度为O(n*log(n))，求高度数组的复杂度为O(n)，创建RMQ的复杂度为O(n*log(n))，查询复杂度O(1)。所以总共的复杂度为O(n*log(n))

其求最长回文子串思路是将这个问题转化为求后缀数组最长公共前缀的问题。虽然后缀数组是处理字符串的神器，但不幸的是在HDU这道题里，还是TLE了，因为存在比它更牛逼的专门为最长回文子串而诞生的 （manacher算法）。不过，由于后缀数组实现最长回文子串实现起来也不容易，我还是把它贴出来仅供学习。

#include<cstdio>
#include<cstring>
#include<cmath>
#include<cstdlib>
#include<iostream>
#include<algorithm>
#include<sstream>
#include<vector>
#include<map>
#include<stack>
#include<list>
#include<set>
#include<queue>
#define LL long long
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1 | 1
using namespace std;
const int maxn=400005,maxe=100005,inf=1<<29;
int n,m,k;
int Rank[maxn],tmp[maxn],sa[maxn],height[maxn];
char s[maxn],s1[maxn];
int dp[maxn][30];
bool cmp(int i,int j)
{
    if(Rank[i]!=Rank[j]) return Rank[i]<Rank[j];
    else
    {
        int ri=i+k<=n?Rank[i+k]:-1;
        int rj=j+k<=n?Rank[j+k]:-1;
        return ri<rj;
    }
}
void get_sa()
{
    for(int i=0;i<=n;i++)
    {
        sa[i]=i;
        Rank[i]=(i<n?s[i]:-1);
    }
    for(k=1;k<=n;k*=2)
    {
        sort(sa,sa+n+1,cmp);
        tmp[sa[0]]=0;
        for(int i=1;i<=n;i++) tmp[sa[i]]=tmp[sa[i-1]]+(cmp(sa[i-1],sa[i])?1:0);
        for(int i=0;i<=n;i++) Rank[i]=tmp[i];
    }
}
void get_lcp()
{
    for(int i=0;i<=n;i++) Rank[sa[i]]=i;
    int h=0;height[0]=0;
    for(int i=0;i<n;i++)
    {
        int j=sa[Rank[i]-1];
        if(h>0) h--;
        for(;j+h<n&&i+h<n;h++)
            if(s[j+h]!=s[i+h]) break;
        height[Rank[i]-1]=h;
    }
}
void InitRMQ()
{
    for(int i=0;i<n;i++) dp[i][0]=height[i];
    for(int j=1;(1<<j)<=n;j++)
        for(int i=0;i+(1<<j)-1<n;i++)
        dp[i][j]=min(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);
}
int RMQ(int l,int r)
{
    int mi=(int)(log((r-l+1)*1.0)/log(2.0));
    return min(dp[l][mi],dp[r-(1<<mi)+1][mi]);
}
int main()
{
    while(~scanf("%s",s1))
    {
        int  n1=strlen(s1);
        memcpy(s,s1,sizeof(s1));
        s[strlen(s)]='$';
        reverse(s1,s1+strlen(s1));
        memcpy(s+strlen(s1)+1,s1,sizeof(s1));
        n=strlen(s);
        get_sa();
        get_lcp();
        n++;
        InitRMQ();
        int ans=0;
        for(int i=0;i<n1;i++)
        {
          int j=2*n1-i;
          int v=RMQ(min(Rank[i],Rank[j]),max(Rank[i],Rank[j])-1);
          ans=max(ans,2*v-1);
      }
      for(int i=1;i<n1;i++)
      {
          int j=2*n1-i+1;
          int v=RMQ(min(Rank[i],Rank[j]),max(Rank[i],Rank[j])-1);
          ans=max(ans,2*v);
      }
      printf("%d\n",ans);
    }
    return 0;
}
//abracadabra

后缀数组具体怎么求回文子串，可以参考 http://wenku.baidu.com/link?url=g8gpzYTDesjlTf3fxVrShwcId5MEiHXnR2K9vsA22OcSxB4vkWe-XgxAihSynE72-AI8qzzJl8gCIdjpRqAtXnVPNDdefhg6Itd9HbVFg7q这个PPT
4. （manacher算法）

前人已经总结了，我就不多说了。可以参考 http://acm.uestc.edu.cn/bbs/simple/?t3258.html

最后终于用manacher算法AC了这道题。AC代码如下

#include<cstdio>
#include<iostream>
using namespace std;
const int maxn=400005;
char s[maxn],str[maxn];
int p[maxn];
void init()
{
    int i,l;
    s[0]='@';s[1]='#';
    for(i=0,l=2;str[i];i++,l+=2) s[l]=str[i],s[l+1]='#';s[l]=0;
}
int Manacher()
{
    int ans=0,mx=0,id;
    for(int i=0;s[i];i++)
    {
        if(mx>i) p[i]=min(p[2*id-i],mx-i);
        else p[i]=1;
        while(s[i+p[i]]==s[i-p[i]]) p[i]++;
        if(i+p[i]>mx) mx=i+p[i],id=i;
        ans=max(ans,p[i]);
    }
    return ans-1;
}
int main()
{
    while(~scanf("%s",str))
    {
        init();
        printf("%d\n",Manacher());
    }
    return 0;
}