Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.
Example:
Input: "babad"
Output: "bab"
Note: "aba" is also a valid answer.
Example:
Input: "cbbd"
Output: "bb"
题目简介
这道题输入是一个字符串，要求输出最长的回文子串。
知识要点
- 动态规划的思想
- 对称的思想
解题思路
Approach 1: Brute Force
暴力法应该是最朴素的算法了：我们查找所有的子串，判断是否为回文并记录最长回文子串。这种算法笔者在此不列代码。
关于时间复杂度，寻找所有子串为O(n2)，判断是否为回文为O(n)，所以总的时间复杂度为O(n3)。
Approach 2: Dynamic Programming
这道题应用动态规划来解题应该还是很容易想到的。设置一个dp布尔型二维数组，其中dp[i][j]表示字符串从第i位置到第j位置（包括i,j）是否为回文。那么很容易得到状态转移方程：<code>if ( dp[i+1][j-1] == true && s[i] == s[j] ) dp[i][j] = true;</code> dp数组初始化操作见代码中pre-process部分。
c++代码如下：
class Solution {
public:
//dynamic programming
string longestPalindrome(string s) {
int len = s.length();
bool dp[1010][1010] = {0};
int i, j;
int maxL=1, start=0, tmpL;
//pre-processing
for (i=0; i<len; ++i){
dp[i][i] = true;
j = i + 1;
if (j < len && s[i] == s[j]){
dp[i][j] = true;
maxL = 2;
start = i;
}
}
//dynamic programming
for (tmpL=3; tmpL<=len; ++tmpL){
for (i=0; i+tmpL-1<len; ++i){
j = i+tmpL-1;
if (dp[i+1][j-1] && s[i]==s[j]){
dp[i][j] = true;
maxL = tmpL;
start = i;
}
}
}
//output
string lp = s.substr(start, maxL);
return lp;
}
};
时间复杂度为O(n^2)
Approach 3: Expand Around Center
第三种算法被称为中心扩展法。核心思想为：从左到右遍历字符串，从“中心”向两边扩展直到不再是回文。该算法要注意的是“中心”的选择：有两种情况，“aba”和“abba”。前者中心为一个字符，后者中心为两个字符。我们对两种情况分别进行处理。
C++代码如下：
class Solution {
public:
//expand around center
string longestPalindrome(string s) {
int len = s.length();
int maxL = 1, start = 0, tmpL;
int i, j, k;
//aba type
for (i=0; i<len; ++i){
j = i-1;
k = i+1;
tmpL = 1;
while(j>=0 && k<len && s[j]==s[k]){
tmpL += 2;
if (tmpL > maxL){
maxL = tmpL;
start = j;
}
j--;
k++;
}
}
//abba type
for (i=0; i<len; ++i){
j = i;
k = i+1;
tmpL = 0;
while(j>=0 && k<len && s[j]==s[k]){
tmpL += 2;
if (tmpL > maxL){
maxL = tmpL;
start = j;
}
j--;
k++;
}
}
//output
string lp = s.substr(start, maxL);
return lp;
}
};
时间复杂度为O(n^2)
Approach 4: Manacher's Algorithm
这个算法算是一个比较冷门的算法了。不过其思想非常有趣，还是很有理解透彻的价值的。网上的众多文章对该算法的解释并不是很清晰，笔者觉得manacher's algorithm这篇文章算是解释最好的一篇了，转过来参考一下。
笔者依据该算法的思想自己用C++实现了一下：
class Solution {
public:
//manacher's algorithm
//add # to the string
string pre_process(string s){
string pps = "#";
for (int i=0; i<s.length(); ++i){
pps += s.substr(i, 1);
pps += "#";
}
return pps;
}
//find the maximum value in p[], which is the radius of the longest palindrome. Return the palindromic string.
string post_process(string s, int p[], int n){
int center, radius=0;
for (int i=0; i<n; ++i){
if (p[i] > radius){
radius = p[i];
center = i;
}
}
string ans = "";
for (int i=center-radius; i<=center+radius; ++i){
if (s[i] != '#')
ans += s.substr(i, 1);
}
return ans;
}
string longestPalindrome(string s){
s = pre_process(s);
int p[2010]; //the radius of palindromic substring, not including character in i
int maxlen = 0, maxi = 0;
p[0] = 0;
//different situations of manacher's algorithm
for (int i=1; i<s.length(); ++i){
// i >= maxlen, the point is out of the range
if (i >= maxlen){
p[i] = 0;
while ( i-(p[i]+1)>=0 && i+(p[i]+1)<s.length() && s[i-(p[i]+1)] == s[i+(p[i]+1)] )
++p[i];
if (i+p[i] > maxlen){
maxi = i;
maxlen = maxi+p[i];
}
}
// i < maxlen, the point is within the range
else{
int j = 2*maxi - i; // the symmetric point
if (j - p[j] < maxi - p[maxi])
p[i] = maxlen - i;
else if (j - p[j] > maxi - p[maxi])
p[i] = p[j];
else{
p[i] = p[j];
while ( i-(p[i]+1)>=0 && i+(p[i]+1)<s.length() && s[i-(p[i]+1)] == s[i+(p[i]+1)] )
++p[i];
if (i+p[i] > maxlen){
maxi = i;
maxlen = maxi+p[i];
}
}
}
}
string ansstr = post_process(s, p, s.length());;
return ansstr;
}
};
该算法时间复杂度达到了O(n)
对代码的一些说明：
- pre-process函数是为字符串没个字符之间添加‘#’，使得“aba”型和“abba”型能够统一处理。
- post-process函数是输出处理。寻找最大回文半径，并将‘#’删除掉。返回最终的输出。
- 算法的主体部分的思想参考manacher's algorithm这篇文章。
