最长回文子串

http://blog.csdn.net/sgbfblog/article/details/7979541

题目描述

给定一个字符串，找出该字符串的最长回文子串。回文字符串指的就是从左右两边看都一样的字符串，如aba，cddc都是回文字符串。字符串abbacdc存在的回文子串有abba和cdc，因此它的最长回文子串为abba。

一个容易犯的错误

初看这个问题可能想到这样的方法：对字符串S逆序得到新的字符串S'，再求S和S'的最长公共子串，这样求出的就是最长回文子串。

如S="caba", S'="abac"，则S和S'的最长公共子串为aba，这个是正确的。

但是如果S = “abacdfgdcaba”, S’ = “abacdgfdcaba”，则S和S'的最长公共子串为abacd，显然这不是回文字符串。因此这种方法是错误的。

 

判定一个字符串是否是回文字符串

要找出最长回文子串，首先要解决判断一个字符串是否是回文字符串的问题。最显而易见的方法是设定两个变量i和j，分别指向字符串首部和尾部，比较是否相等，然后i++，j--，直到i >= j为止。下面的代码是判断字符串str[i, j]是不是回文字符串，即字符串str从i到j的这一段子串是否是回文字符串，在后面会用到这个方法。

[cpp]  view plain copy

1. bool isPalindrome(string str, int start, int end)   
2. {  
3.     while (start < end) {  
4.         if (str[start] != str[end])  
5.             return false;  
6.         ++start, --end;  
7.     }  
8.     return true;  
9. }  

蛮力法求最长回文子串

蛮力法通过对字符串所有子串进行判断，如果是回文字符串，则更新最长回文的长度。因为长度为N的字符串的子串一共可能有(1+N)*N/2个，每次判断子串需要O(N)的时间，所以一共需要O(N^3)时间来求取最长回文子串。

[cpp]  view plain copy

1. string longestPalindrome(string str)   
2. {  
3.     int len = str.length(), max = 1;   
4.     int start=0;  
5.         /*遍历字符串所有的子串，若子串为回文字符串则更新最长回文的长度*/  
6.         for (int i=0; i<len; i++) {  
7.         for (int j=i; j<len; j++) {  
8.             if (isPalindrome(str, i, j)) { //如果str[i,j]是回文，则判断其长度是否大于最大值，大于则更新长度和位置  
9.                 int pLen = j - i + 1;  
10.                 if (pLen > max) {  
11.                     start = i;  //更新最长回文起始位置  
12.                     max = pLen; //更新最长回文的长度  
13.                 }  
14.             }  
15.         }  
16.     }  
17.     return str.substr(start, max);   
18. }  

动态规划法求最长回文子串

因为蛮力法判定回文的时候需要很多重复的计算，所以可以通过动态规划法来改进该算法。假定我们知道“bab”是回文，则“ababa”也一定是回文。

[cpp]  view plain copy

1. 定义P[i, j] = true 如果子串S[i, j]是回文字符串。  
2. 则 P[i, j] <- (P[i+1, j-1] && S[i]==S[j])。  

Base Case如下：

[cpp]  view plain copy

1. P[ i, i ] ← true  
2. P[ i, i+1 ] ← ( Si = Si+1 )  

据此动态规划方法的代码如下, 该方法的时间复杂度为O(N^2)，空间复杂度为O(N^2)。

[cpp]  view plain copy

1. string longestPalindromeDP(string s)  
2. {  
3.     int n = s.length();  
4.     int longestBegin = 0, maxLen = 1;  
5.     bool table[1000][1000] = {false};  
6.     for (int i=0; i<n; i++)  
7.         table[i][i] = true;  
8.     for (int i=0; i<n-1; i++) {  
9.         if (s[i] == s[i+1]) {  
10.             table[i][i+1] = true;  
11.             longestBegin = i;  
12.             maxLen = 2;  
13.         }  
14.     }  
15.         /*依次求table[i][i+2]...table[i][i+n-1]等*/  
16.     for (int len=3; len<=n; ++len) {  
17.         for (int i=0; i<n-len+1; ++i) {  
18.             int j = i + len - 1;  
19.             if (s[i]==s[j] && table[i+1][j-1]) {  
20.                 table[i][j] = true;  
21.                 longestBegin = i;  
22.                 maxLen = len;  
23.             }  
24.         }  
25.     }  
26.     return s.substr(longestBegin, maxLen);  
27. }  

 

中心法求最长回文子串

还有一个更简单的方法可以使用O(N^2)时间、不需要额外的空间求最长回文子串。我们知道回文字符串是以字符串中心对称的，如abba以及aba等。一个更好的办法是从中间开始判断，因为回文字符串以字符串中心对称。一个长度为N的字符串可能的对称中心有2N-1个，至于这里为什么是2N-1而不是N个，是因为可能对称的点可能是两个字符之间，比如abba的对称点就是第一个字母b和第二个字母b的中间。因此可以依次对2N-1个中心点进行判断，求出最长的回文字符串即可。根据该思路可以写出下面的代码。

[cpp]  view plain copy

1. string expandAroundCenter(string s, int l, int r)  
2. {  
3.     int n = s.length();  
4.     while (l>=0 && r<=n-1 && s[l]==s[r]) {  
5.         l--, r++;  
6.     }  
7.     return s.substr(l+1, r-l-1);  
8. }  
9.   
10. string longestPalindrome3(string s)  
11. {  
12.     int n = s.length();  
13.     if (n == 0) return "";  
14.     string longest = s.substr(0, 1);  
15.     for (int i=0; i<n; i++) {  
16.         string p1 = expandAroundCenter(s, i, i); //以位置i为中心的最长回文字符串  
17.         if (p1.length() > longest.length())  
18.             longest = p1;  
19.   
20.         string p2 = expandAroundCenter(s, i, i+1); //以i和i+1之间的位置为中心的最长回文字符串  
21.         if (p2.length() > longest.length())  
22.             longest = p2;  
23.     }  
24.     return longest;  
25. }  

Manacher回文串算法学习记录

http://hi.baidu.com/chenwenwen0210/item/482c84396476f0e02f8ec230

#include<stdio.h>
#include<math.h>
#include<string.h>
#include<map>
#include<algorithm>
#include<queue>
using namespace std;
typedef __int64 lld;
  
const int MAX=1100000*2;
char str[MAX];//原字符串
char sb[MAX];
int p[MAX];//表示以i为中心的回文半径，
/*p[i]-1刚好是原字符串以第i个为中心的回文串长度。
画画图就知道了，因为两端配匹的肯定是字符g
*/
/*
Mancher主算法。
学习地址：http://blog.csdn.net/ggggiqnypgjg/article/details/6645824
功能：求出以i为中心的回文半径p[i];
参数：传入构造好的字符串长度
特殊说明：因为前面加了一个无效字符，所以下标从1开始。
例题：http://acm.hdu.edu.cn/showproblem.php?pid=3068
http://poj.org/problem?id=3974
http://acmpj.zstu.edu.cn/JudgeOnline/showproblem?problem_id=3780
http://acmpj.zstu.edu.cn/JudgeOnline/showproblem?problem_id=3769
http://acm.hust.edu.cn:8080/judge/contest/view.action?cid=12581#problem/A
http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3661
http://acm.hdu.edu.cn/showproblem.php?pid=3948
  
*/
void Manacher(int n)
{
    int i;
    int mx=0;//记录前面回文串最长影响到的地方。不一定是最长回文串造成的。
    int id;//最长影响串的ID;
    p[0]=0;
    for(i=1;i<n;i++)
    {
        p[i]=1;//至少是1
        if(mx>i)//i受到影响即，id+p[id]-1>=i;
        {
            p[i]=p[2*id-i];//2*id-i是i关于id的对称点相当于是id-(i-id);
            if(mx-i<p[i])p[i]=mx-i;
            //由于对称点的回文半径可能超过mx-i,因为mx后面的还没有配过
            //所以要取小的。等等继续配
        }
  
        //向两端配匹
        while(str[i-p[i]]==str[i+p[i]])p[i]++;
  
        if(i+p[i]>mx)
        {
            mx=i+p[i];
            id=i;
        }
    }
}
  
/*
功能：构造字符串，在每一个字符前插入一个，g,一般用'#'
第一个字符前面再插入,first,一般用'$'
最后再插入g字符
总之不是在输入中出现的字符就行了。
比如abb,构造成$#a#b#b#
参数：<first,第一个字符>，<g,一般字符>
  
返回值：构造好的字符串长度
*/
int pre(char first='$',char g='#')
{
    int i,n=0;
    strcpy(sb,str);
    str[0]=first;
    n++;
    for(i=0;sb[i];i++)
    {
        str[n++]=g;
        str[n++]=sb[i];
    }
  
    str[n++]=g;
    str[n]=0;
    return n;
}
int main()
{
    int n;
    int i;
    int CS=1;
    while(scanf("%s",str)!=EOF)
    {
        if(strcmp(str,"END")==0)break;
  
        n=pre();
        Manacher(n);
        int ans=0;
  
        for(i=1;i<n;i++)
        {
            if(p[i]>ans)ans=p[i];
        }
  
        printf("%d\n",ans-1);
    }
    return 0;
}

Manacher回文串算法学习记录