leetcode5-Longest Palindromic Substring(最长回文子串)

问题描述：

Given a string S, find the longest palindromic substring in S. You may assume that the maximum length of S is 1000, and there exists one unique longest palindromic substring.

给定一个字符串，求出其最长回文子串。注意与子序列的区别：子串连续。

问题求解：

方法一：暴力法。

求出每一个子串，之后判断是不是回文，找到最长的那个。

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

有可能超时。

class Solution {
public:
string longestPalindrome(string s) {
int length=s.size();//字符串长度
if(length==1) return s;
int maxlength=0;//最长回文字符串长度
int start;//最长回文字符串起始地址
for(int i=0;i<length;i++)//起始地址
for(int j=i+1;j<length;j++)//结束地址
{
int tmp1,tmp2;
for(tmp1=i,tmp2=j;tmp1<tmp2;tmp1++,tmp2--)//判断是不是回文
{
if(s.at(tmp1)!=s.at(tmp2))
break;
}
if(tmp1>=tmp2&&j-i>maxlength)
{
maxlength=j-i+1;
start=i;
}
}
if(maxlength>0)
return s.substr(start,maxlength);//求子串
return NULL;
}
};

方法二：利用著名的Manacher算法，O(N)时间O(N)空间。

首先我们把字符串S改造一下变成T，改造方法是：在S的每个字符之间和S首尾都插入一个”#”。很巧妙地把奇数长度回文串与偶数长度回文串统一考虑。

例如，S="abaaba"，那么T="#a#b#a#a#b#a#"。

这样一来，原来的奇数长度回文串还是奇数长度，偶数长度的也变成以‘#’为中心奇数回文串了。

为了防止求P[i]向两边扩展时可能数组越界，我们需要在数组最前面和最后面分别加一个特殊字符如^ 和 $，最终

T="^#a#b#a#a#b#a#$"

。

为了改进最坏的情况，我们把各个Ti处的回文半径存储到数组P，用P[i]表示以Ti为中心的回文长度。那么当我们求出所有的P[i]，取其中最大值就能找到最长回文子串了。

对于上文的示例，我们先直接写出所有的P研究一下。

i = 0 1 2 3 4 5 6 7 8 9 A B C
T = # a # b # a # a # b # a #
P = 0 1 0 3 0 1 6 1 0 3 0 1 0

显然最长子串就是以P[6]为中心的”abaaba”。

你是否发现了，在插入”#”后，长度为奇数和偶数的回文都可以优雅地处理了？这就是其用处。

我们来看一个重叠得更典型的例子，即S=”babcbabcbaccba”。

扩展过程：



总结一下上述分析过程，就是这个算法的关键部分了。

if P[ i' ] < R – i,

then P[ i ] ← P[ i' ]

else P[ i ] ≥ R - i. (此时要穿过R逐个字符判定P[i]).

很明显C的位置也是需要移动的，这个很容易：

如果i处的回文超过了R，那么就C=i，同时相应改变L和R即可。

代码如下：

class Solution {
public:
// Transform S into T.
// For example, S = "abba", T = "^#a#b#b#a#$".
// ^ and $ signs are sentinels appended to each end to avoid bounds checking
string preProcess(string s) {
int n = s.length();
if (n == 0) return "^$";

string ret = "^";
for (int i = 0; i < n; i++)
{//截取字符串内容最好用s.substr(i,1),若用s[i]与“#”相加出现错误
ret += "#" + s.substr(i, 1);
}
ret += "#$";
return ret;
}

string longestPalindrome(string s) {
string T = preProcess(s);//(1)预处理
int n = T.length();
//int *P = new int
;
vector<int> P(n);
int C = 0, R = 0;
for (int i = 1; i < n-1; i++) {
//(2)i以C为中心的对称点
int i_mirror = 2*C-i; // equals to i' = C - (i-C)
//(3)若R>i,说明当前i在C和R之间，可以利用回文的对称属性
P[i] = (R > i) ? min(R-i, P[i_mirror]) : 0;
//(4)以i为中心扩展回文的长度
while (T[i + 1 + P[i]] == T[i - 1 - P[i]])
P[i]++;
//(5)如果以i为中心的回文扩展超出了右边界R，则更新回文中心C和回文边界R
if (i + P[i] > R) {
C = i;
R = i + P[i];
}
}
//以上操作得到了一个P[]数组
//(6)在P中找到最大元素，即为最长回文串的长度
int maxLen = 0;
int centerIndex = 0;
for (int i = 1; i < n-1; i++) {
if (P[i] > maxLen) {
maxLen = P[i];//回文长度
centerIndex = i;//回文中心
}
}
//delete[] P;
//(7)上述得到的centerIndex是在T中的，要以此得到在S中的
//最长回文子串的起点：(centerIndex - 1 - maxLen)/2
return s.substr((centerIndex - 1 - maxLen)/2, maxLen);
}
};

参考：http://articles.leetcode.com/longest-palindromic-substring-part-ii