最长回文子串

http://www.cnblogs.com/xiuyangleiasp/p/5070991.html

问题描述
给定一个字符串，求它的最长回文子串的长度。
回文串就是正着读和反着读都一样的字符串。

分析与求解

解法一 蛮力法

最容易想到的就是蛮力求解，即求出该字符串的每一个子串，再判断子串是否是回文串，找到最长的那个。其中求出每个子串的时间复杂度为O(n2)，判断是否为回文串的复杂度为O(n)，两者是相乘关系，所以整个算法的时间复杂度为O(n3)。

/*
* 判断str[i...j]是否是回文串
*/
bool isPalindrome(const char *str, int begin, int end)
{
while (begin <= end)
{
if (str[begin] == str[end])
{
begin++;
end--;
}
else
return false;
}
return true;
}

/*
*返回字符串str的最长回文子串的长度
*/
int longestPalindrome(const char *str)
{
if (str == NULL)
return 0;
int len = strlen(str);
if (len == 1)
return 1;
int longest = 1;
for (int i = 0; i < len; i++)
for (int j = i + 1; j < len; j++)
if (isPalindrome(str, i, j) == true)
longest = longest < j - i + 1 ? j - i + 1 : longest;
return longest;
}

解法二 中心扩展法

假设一个字符串str是回文串，那么它一定是左右对称的，所以该字符串以某个字符str[mid]为中心的前缀和后缀一定是相同的。例如，对于回文串"aba"，以'b'为中心，它的前缀和后缀都是'a'。故，可以枚举字符串的每个字符作为回文串的中心位置，左右扩展得到回文串，然后比较得到最长的长度。
注意：这里需要考虑到一个特殊情况，即存在"YXaaXY"这样长度为偶数的特殊子串，这里可以将"aa"视为'a'。
该算法的时间复杂度为O(n2)。

/*
* 以mid为中心轴的回文子串的长度
*/
int palindrome(const char *str, int mid)
{
int left = mid - 1, right = mid + 1;
int len = strlen(str);
while (str[mid] == str[right])
right++;
while (left >= 0 && right < len && str[left] == str[right])
{
left--;
right++;
}
return right - left - 1;
}

/*
*返回字符串str的最长回文子串的长度
*/
int longestPalindrome(const char *str)
{
if (str == NULL) return 0;
int len = strlen(str);
if (len == 1)return 1;
int longest = 1;
for (int i = 0; i < len; i++)
{
int tmp = palindrome(str, i);
if (tmp < longest)
longest = tmp;
}
return longest;
}

解法三 动态规划

对于字符串str，假设dp[i,j]=1表示str[i...j]是回文子串，那个必定存在dp[i+1,j-1]=1。这样最长回文子串就能分解成一系列子问题，可以利用动态规划求解了。
首先构造状态转移方程



上面的状态转移方程表示，当str[i]=str[j]时，如果str[i+1...j-1]是回文串，则str[i...j]也是回文串；如果str[i+1...j-1]不是回文串，则str[i...j]不是回文串。
初始状态

dp[i][i]=1
dp[i][i+1]=1 if str[i]==str[i+1]

上式的意义是单个字符，两个相同字符都是回文串。

/*
*返回字符串str的最长回文子串的长度
*/
int longestPalindrome(const char *str)
{
if (str == NULL) return 0;
int len = strlen(str);
if (len == 1)return 1;
int longest = 1;
int dp[100][100];
for (int i = 0; i < len; i++)
{
dp[i][i] = 1;
if (str[i] == str[i + 1])
dp[i][i + 1] = 1;
}

for (int i = 0; i < len; i++)
{
for (int j = i + 2; j <= len; j++)
{
if (str[i] == str[j])
{
dp[i][j] = dp[i][j - 1];
if (dp[i][j] == 1)
{
int tmp = j - i + 1;
if (longest < tmp)longest = tmp;
}
}
else dp[i][j] = 0;
}
}
return longest;
}

根据代码不难看出，动态规划的时间复杂度也为O(n2)。

解法四 Manacher算法

上面的解法从时间复杂度的角度来说，效率都较低。是否存在更快的算法呢？答案是肯定的，就是Manancher算法。Manancher算法可以在线性时间复杂度内求出一个字符串的最长回文子串，达到理论的下界。下面介绍Manacher算法的原理和步骤。
Manacher算法首先通过在每个字符的两边都插入一个特殊的符号（未在字符串中出现过），将所有可能的回文子串都转换成奇数。例如"aba"的两边都插入字符'#'就变成了"#a#b#a#"。为了更好处理越界问题，可以在字符串的开始和结尾加入另一个特殊字符，例如在"#a#b#a#"的开始和结尾插入字符'′变成"#a#b#a#$"。

P数组简介
Manacher算法利用一个辅助数组P[i]表示以字符S[i]为中心的最长回文子串的最右（左）字符到S[i]的距离（包括S[i]）。例如以S[i]为中心的最长回文子串是S[l..r]，则P[i]=r-i+1。
对于字符串"aabba"，插入'#'和'′两个字符后，变成了S[]="#a#a#b#b#a#$"，可以得到的P[i]数组为：



P数组有一个性质：P[i]-1是该回文子串在原来字符串中的长度。
证明
由于在转换后得到的字符串S中，所有的回文子串的长度都是奇数，所以对于以S[i]为中心的最长回文子串的长度为2P[i]-1。经过观察可知，S中所有的回文子串，其分隔符的数量一定比其他字符多1，即P[i]个字符，剩下P[i]-1字符来自原字符串，所以该回文串在原字符串中的长度是P[i]-1。
利用这个性质，原问题就转换成求所有的P[i]。
P数组的计算
如何计算P[i]呢？首先从左至右依次计算P[i]，但计算P[i]时，P[j](j<i)已经计算完毕。增加两个辅助变量id和mx，其中id表示最大回文子串中心的位置，mx=id+P[id]，即回文子串的边界。则分为两种情况：

i≤mx

令j=2*id-i，j为i关于id的对称点。
当mx-i>P[i]时，以S[j]为中心的回文子串就包含在以S[id]为中心的回文子串中，由于i和j对称，所以S[i]为中心的回文子串必然被包含在以S[id]为中心的回文子串中，故P[i]=P[j]=P[2*id-i]。如下图所示。



当mx-i≤P[i]，以S[j]为中心的回文子串不一定完全包含在以S[id]为中心的回文子串中，但基于对称性可知，以S[i]和S[j]为中心的回文子串在[2*id-mx,mx]范围内的部分是相同，即下图中的方框部分是相同的。换言之，以S[i]为中心的回文子串向右至少会扩展到mx的位置，从而P[i]≥mx-i。至于mx之后的部分，则需要进一步匹配。



根据上面的推导，可以得出结论：如果i<mx，则P[i]≥min(P[2*id-i],mx-i)。

i>mx

如果i比mx大，则说明对于以S[i]为中心的回文子串还有一部分没有匹配，由于无法对P[i]做更多的假设，只能先令P[i]=1，然后在继续进行相关匹配。
综上所述，P[i]的计算公式为



时间复杂度
由于Manacher算法只有在遇到还未匹配的位置时才进行匹配，已经匹配过的位置不再匹配，所以对于对于字符串S的每一个位置，都只进行一次匹配，所以算法的总体复杂度为O(n)。

int p[100];
void init(const char *str, char *tmp)
{
tmp[0] = '@';
int len = strlen(str);
for (int i = 1; i < 2 * len; i += 2)
{
tmp[i] = '#';
tmp[i + 1] = str[i / 2];
}
tmp[2 * len + 1] = '#';
tmp[2 * len + 2] = '@';
tmp[2 * len + 3] = 0;
}

//Manacher算法计算过程
int longestPalindrome(const char *str)
{
int mx = 0, ans = 0, id = 0;
int len = strlen(str);
int longest = 0;
for (int i = 1; i <= len; i++)
{
if (mx >= i)
p[i] = min(p[2 * id - i], mx - i);
else p[i] = 1;
while (str[i + p[i]] == str[i - p[i]])
p[i]++;
if (p[i] + i > mx)
{
mx = p[i] + i;
id = i;
}
longest = max(longest, p[id]);
}
return longest - 1;
}