关于这道题,我的第一想法是针对回文串的特性,对字符串的每个字符(奇数回文串)或者每两个字符(偶数回文串)向两边开始扩展分析。在这个过程中不断发现最新的最长回文串。显然这个算法的复杂度为O(n^2)
class Solution
{
public:
string longestPalindrome(string s)
{
//中心扩展法
int maxlen;
int prev;
int next;
string result;
maxlen = 0;
//回文串为奇数时
for (int i = 0; i < s.size(); i++)
{
prev = i;
next = i;
while (true)
{
prev = prev - 1;
next = next + 1;
if (prev < 0 || next > s.size() - 1)
{
if ((next - 1) - (prev + 1) + 1 > maxlen)
{
maxlen = (next - 1) - (prev + 1) + 1;
result.assign(s, prev + 1, maxlen);
}
break;
}
if (s[prev] != s[next])
{
if ((next - 1) - (prev + 1) + 1 > maxlen)
{
maxlen = (next - 1) - (prev + 1) + 1;
result.assign(s, prev + 1, maxlen);
}
break;
}
}
}
//回文串为偶数时
for (int i = 0; i < s.size(); i++)
{
prev = i;
next = i+1;
if (prev >= 0 && next <= s.size() - 1 && s[prev] == s[next])
{
while (true)
{
prev = prev - 1;
next = next + 1;
if (prev < 0 || next > s.size() - 1)
{
if ((next - 1) - (prev + 1) + 1 > maxlen)
{
maxlen = (next - 1) - (prev + 1) + 1;
result.assign(s, prev + 1, maxlen);
}
break;
}
if (s[prev] != s[next])
{
if ((next - 1) - (prev + 1) + 1 > maxlen)
{
maxlen = (next - 1) - (prev + 1) + 1;
result.assign(s, prev + 1, maxlen);
}
break;
}
}
}
}
return result;
}
};
====================================================================
第二种方法,使用DP。这个是在网上搜集到的。
回文字符串的子串也是回文,比如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])
string findLongestPalindrome(string &s)
{
const int length=s.size();
int maxlength=0;
int start;
bool P[50][50]={false};
for(int i=0;i<length;i++)//初始化准备
{
P[i][i]=true;
if(i<length-1&&s.at(i)==s.at(i+1))
{
P[i][i+1]=true;
start=i;
maxlength=2;
}
}
for(int len=3;len<length;len++)//子串长度
for(int i=0;i<=length-len;i++)//子串起始地址
{
int j=i+len-1;//子串结束地址
if(P[i+1][j-1]&&s.at(i)==s.at(j))
{
P[i][j]=true;
maxlength=len;
start=i;
}
}
if(maxlength>=2)
return s.substr(start,maxlength);
return NULL;
}