面试算法题精讲：最长回文子串
题目来源：5. 最长回文子串
题目描述：
给你一个字符串 s，找到 s 中最长的回文子串。
如果字符串的反序与原始字符串相同，则该字符串称为回文字符串。
解法1：动态规划
对于一个子串而言，如果它是回文串，并且长度大于 2，那么将它首尾的两个字母去除之后，它仍然是个回文串。
根据这样的思路，我们就可以用动态规划的方法解决本题。
我们用 dp[i][j] 表示 s[i…j] 是否是回文串。
状态转移方程：dp[i][j] = dp[i+1][j-1] ∧ (s[i] == s[j])
动态规划中的边界条件：
- dp[i][i] == true，对于长度为 1 的子串，它显然是个回文串。
- dp[i][i+1] = (s[i] == s[i+1])，对于长度为 2 的子串，只要它的两个字母相同，它就是一个回文串。
根据这个思路，我们就可以完成动态规划了，最终的答案即为所有 dp[i][j]=true 中 j−i+1（即子串长度）的最大值。注意：在状态转移方程中，我们是从长度较短的字符串向长度较长的字符串进行转移的，因此一定要注意动态规划的循环顺序。
我们使用2层循环，外层枚举子串的长度 len，内层枚举子串起点 i，子串的终点 j = i + len - 1。之后进行转移转移即可。
代码：
class Solution
{
public:
string longestPalindrome(string s)
{
// 特判
if (s.size() < 2)
return s;
int n = s.size(), maxLen = 1, begin = 0;
// 状态矩阵
vector<vector<int>> dp(n, vector<int>(n, false));
// dp[i][j] 表示 s[i...j] 是否是回文串
// 初始化：所有长度为 1 的子串都是回文串
for (int i = 0; i < n; i++)
dp[i][i] = true;
// 状态转移
for (int len = 2; len <= n; len++) // 枚举子串长度
for (int i = 0; i < n; i++) // 枚举左边界
{
int j = i + len - 1; // 计算右边界
if (j >= n) // 右边界越界
break;
if (s[i] != s[j])
dp[i][j] = false;
else
{
if (len <= 3)
dp[i][j] = true;
else
dp[i][j] = dp[i + 1][j - 1];
}
if (dp[i][j] == true && j - i + 1 > maxLen)
{
maxLen = j - i + 1;
begin = i;
}
}
return s.substr(begin, maxLen);
}
};
结果：
复杂度分析：
时间复杂度：O(n2)，其中 n 是字符串 s 的长度。
空间复杂度：O(n2)，其中 n 是字符串 s 的长度。
解法2：中心拓展算法
「中心扩散法」的基本思想是：遍历每一个下标，以这个下标为中心，利用「回文串」中心对称的特点，往两边扩散，看最多能扩散多远。
从每一个位置出发，向两边扩散即可。遇到不是回文的时候结束。
每个位置向两边扩散都会出现一个窗口大小（len = right - left）。如果 len>maxLen（用来表示最长回文串的长度），则更新 maxLen 的值。
因为我们最后要返回的是具体子串，而不是长度。因此，还需要记录一下 maxLen 时的起始位置 start。
代码：
/*
* @lc app=leetcode.cn id=5 lang=cpp
*
* [5] 最长回文子串
*/
// @lc code=start
class Solution
{
public:
string longestPalindrome(string s)
{
int n = s.length();
int start = 0, end = 0;
auto expendAroundCenter = [&](int left, int right) -> pair<int, int>
{
while (left >= 0 && right < n && s[left] == s[right])
{
left--;
right++;
}
return {left + 1, right - 1};
};
for (int i = 0; i < n; i++)
{
auto [left1, right1] = expendAroundCenter(i, i);
if (right1 - left1 > end - start)
{
start = left1;
end = right1;
}
auto [left2, right2] = expendAroundCenter(i, i + 1);
if (right2 - left2 > end - start)
{
start = left2;
end = right2;
}
}
int len = end - start + 1;
return s.substr(start, len);
}
};
// @lc code=end
结果：
复杂度分析：
时间复杂度：O(n2)，其中 n 是字符串 s 的长度。
空间复杂度：O(1)。
解法3：Manacher 算法
算法详解：https://blog.csdn.net/dyx404514/article/details/42061017。
代码：
class Solution
{
private:
string manacher(string s)
{
// 特判
if (s.empty() || s.size() < 2)
return s;
// 对原始字符串 s 做处理，添加分隔符（例如：将 abc 变成 #a#b#c#）
string str = addBoundaries(s, '#');
int n = str.size();
// right 表示已经探测到的字符串最右边的可达范围
int right = 0;
// center 表示根据最右边的可达范围的中心对称位置
int center = 0;
int start = 0, maxLen = 0;
// p 数组记录所有已探测过的回文半径，后面我们再计算 i 时，根据 p[i_mirror] 计算 i
vector<int> p(n, 0);
// 从左到右遍历处理过的字符串，求每个字符的回文半径
for (int i = 0; i < n; i++)
{
// 根据i和right的位置分为两种情况：
// 1. i <= right，利用已知的信息来计算 i
// 2. i > right，说明 i 的位置时未探测过的，只能用中心探测法
if (right >= i)
{
// 这句是关键，不用再像中心探测那样，一点点的往左/右扩散，根据已知信息
// 减少不必要的探测，必须选择两者中的较小者作为左右探测起点
int minArmLen = min(right - i, p[2 * center - i]);
p[i] = expand(str, i - minArmLen, i + minArmLen);
}
else // i 落在 right 右边，是没被探测过的，只能用中心探测法
p[i] = expand(str, i, i);
// 大于right，说明可以更新最右端范围了，同时更新 center
if (i + p[i] > right)
{
center = i;
right = i + p[i];
}
// 找到了一个更长的回文半径，更新原始字符串的 start 位置
if (p[i] > maxLen)
{
maxLen = p[i];
start = (i - p[i]) / 2;
}
}
// 根据 start 和 maxLen ，从原始字符串中截取一段返回
return s.substr(start, maxLen);
}
// 辅函数 - 以s [left...right] 为起点，计算回文半径（可拓展的步数）
int expand(string s, int left, int right)
{
while (left >= 0 && right < s.size() && s[left] == s[right])
{
left--;
right++;
}
// 由于while循环退出后left和right各多走了一步，所以在返回的总长度时要减去2
return (right - left - 2) / 2;
}
// 辅函数 - 对原始字符串 s 进行预处理（添加分隔符）
string addBoundaries(string s, char divide)
{
if (s.empty())
return "";
string t;
for (char &c : s)
{
t += divide;
t += c;
}
t += divide;
return t;
}
public:
string longestPalindrome(string s)
{
return manacher(s);
}
};
结果：
复杂度分析：
时间复杂度：O(n)，其中 n 是字符串 s 的长度。
空间复杂度：O(n)，其中 n 是字符串 s 的长度。
