最长回文子串

题目描述

对于一个字符串，请设计一个高效算法，计算其中最长回文子串的长度。

给定字符串A以及它的长度n，请返回最长回文子串的长度。

测试样例：

"abc1234321ab",12

返回：7

之前注册过hihoCoder，现在看到推出编程字符串专题，有这个题目，自己写一下。

回文是指正着读和倒着读，结果一些样，比如abcba或abba。

题目是要在一个字符串中要到最长的回文子串。

1、暴力法

最容易想到的就是暴力破解，求出每一个子串，之后判断是不是回文，找到最长的那个。

求每一个子串时间复杂度O(N^2)，判断子串是不是回文O(N)，两者是相乘关系，所以时间复杂度为O(N^3)。

[cpp]  view plain  copy

 

1. string findLongestPalindrome(string &s)  
2. {  
3.     int length=s.size();//字符串长度  
4.     int maxlength=0;//最长回文字符串长度  
5.     int start;//最长回文字符串起始地址  
6.     for(int i=0;i<length;i++)//起始地址  
7.         for(int j=i+1;j<length;j++)//结束地址  
8.         {  
9.             int tmp1,tmp2;  
10.             for(tmp1=i,tmp2=j;tmp1<tmp2;tmp1++,tmp2--)//判断是不是回文  
11.             {  
12.                 if(s.at(tmp1)!=s.at(tmp2))  
13.                     break;  
14.             }  
15.             if(tmp1>=tmp2&&j-i>maxlength)  
16.             {  
17.                 maxlength=j-i+1;  
18.                 start=i;  
19.             }  
20.         }  
21.         if(maxlength>0)  
22.             return s.substr(start,maxlength);//求子串  
23.         return NULL;  
24. }  

2、动态规划

回文字符串的子串也是回文，比如P[i,j]（表示以i开始以j结束的子串）是回文字符串，那么P[i+1,j-1]也是回文字符串。这样最长回文子串就能分解成一系列子问题了。这样需要额外的空间O（N^2)，算法复杂度也是O(N^2)。

首先定义状态方程和转移方程：

P[i,j]=0表示子串[i,j]不是回文串。P[i,j]=1表示子串[i,j]是回文串。

P[i,i]=1

        

P[i,j]｛=P[i+1,j-1],if(s[i]==s[j])

   =0 ,if(s[i]!=s[j])

[cpp]  view plain  copy

 

1. string findLongestPalindrome(string &s)  
2. {  
3.     const int length=s.size();  
4.     int maxlength=0;  
5.     int start;  
6.     bool P[50][50]={false};  
7.     for(int i=0;i<length;i++)//初始化准备  
8.     {  
9.         P[i][i]=true;  
10.         if(i<length-1&&s.at(i)==s.at(i+1))  
11.         {  
12.             P[i][i+1]=true;  
13.             start=i;  
14.             maxlength=2;  
15.         }  
16.     }  
17.     for(int len=3;len<length;len++)//子串长度  
18.         for(int i=0;i<=length-len;i++)//子串起始地址  
19.         {  
20.             int j=i+len-1;//子串结束地址  
21.             if(P[i+1][j-1]&&s.at(i)==s.at(j))  
22.             {  
23.                 P[i][j]=true;  
24.                 maxlength=len;  
25.                 start=i;  
26.             }  
27.         }  
28.     if(maxlength>=2)  
29.         return s.substr(start,maxlength);  
30.     return NULL;  
31. }  

3、中心扩展

中心扩展就是把给定的字符串的每一个字母当做中心，向两边扩展，这样来找最长的子回文串。算法复杂度为O(N^2)。

但是要考虑两种情况：

1、像aba，这样长度为奇数。

2、想abba，这样长度为偶数。

[cpp]  view plain  copy

 

1. string findLongestPalindrome(string &s)  
2. {  
3.     const int length=s.size();  
4.     int maxlength=0;  
5.     int start;  
6.   
7.     for(int i=0;i<length;i++)//长度为奇数  
8.     {  
9.         int j=i-1,k=i+1;  
10.         while(j>=0&&k<length&&s.at(j)==s.at(k))  
11.         {  
12.             if(k-j+1>maxlength)  
13.             {  
14.                 maxlength=k-j+1;  
15.                 start=j;  
16.             }  
17.             j--;  
18.             k++;  
19.         }  
20.     }  
21.   
22.     for(int i=0;i<length;i++)//长度为偶数  
23.     {  
24.         int j=i,k=i+1;  
25.         while(j>=0&&k<length&&s.at(j)==s.at(k))  
26.         {  
27.             if(k-j+1>maxlength)  
28.             {  
29.                 maxlength=k-j+1;  
30.                 start=j;  
31.             }  
32.             j--;  
33.             k++;  
34.         }  
35.     }  
36.     if(maxlength>0)  
37.         return s.substr(start,maxlength);  
38.     return NULL;  
39. }  

4、Manacher法

Manacher法只能解决例如aba这样长度为奇数的回文串，对于abba这样的不能解决，于是就在里面添加特殊字符。我是添加了“#”，使abba变为a#b#b#a。这个算法就是利用已有回文串的对称性来计算的，具体算法复杂度为O(N)，我没看出来，因为有两个嵌套的for循环。

具体原理参考这里。

测试代码中我没过滤掉“#”。

[cpp]  view plain  copy

 

1. #define min(x, y) ((x)<(y)?(x):(y))  
2. #define max(x, y) ((x)<(y)?(y):(x))  
3. string findLongestPalindrome3(string s)  
4. {  
5.     int length=s.size();  
6.     for(int i=0,k=1;i<length-1;i++)//给字符串添加 #  
7.     {  
8.         s.insert(k,"#");  
9.         k=k+2;  
10.     }  
11.     length=length*2-1;//添加#后字符串长度  
12.     int *rad=new int[length]();  
13.     rad[0]=0;  
14.     for(int i=1,j=1,k;i<length;i=i+k)  
15.     {  
16.         while(i-j>=0&&i+j<length&&s.at(i-j)==s.at(i+j))  
17.             j++;  
18.         rad[i]=j-1;  
19.         for(k=1;k<=rad[i]&&rad[i-k]!=rad[i]-k;k++)//镜像,遇到rad[i-k]=rad[i]-k停止，这时不用从j=1开始比较  
20.             rad[i+k]=min(rad[i-k],rad[i]-k);  
21.   
22.         j=max(j-k,0);//更新j  
23.           
24.     }  
25.     int max=0;  
26.     int center;  
27.     for(int i=0;i<length;i++)  
28.     {  
29.         if(rad[i]>max)  
30.         {  
31.             max=rad[i];  
32.             center=i;  
33.         }  
34.     }  
35.     return s.substr(center-max,2*max+1);  
36.   
37. }