1. 理解回文子串问题
回文子串是算法面试中的经典问题，也是字符串处理的基础题型之一。所谓回文串，指的是正读和反读都相同的字符串，比如"aba"、"abba"、"a"都是回文串。而最长回文子串问题，就是要求我们在给定的字符串中找出最长的那个回文子串。
这个问题看似简单，但想要高效解决却需要一些技巧。暴力解法虽然直观，但时间复杂度高达O(n³)，显然不适合处理较长的字符串。而动态规划方法可以将时间复杂度优化到O(n²)，是更优的选择。
2. 动态规划解法详解
2.1 动态规划思路解析
动态规划解决这个问题的核心思想是利用已经计算过的子问题的解来构建更大问题的解。我们定义一个二维数组dp，其中dp[i][j]表示字符串s从i到j的子串是否是回文串。
状态转移方程如下：
- 当j - i <= 2时（即子串长度为1、2或3），dp[i][j] = (s[i] == s[j])
- 当j - i > 2时，dp[i][j] = (s[i] == s[j]) && dp[i+1][j-1]
这个方程的意思是：一个较长的子串要成为回文串，首先它的首尾字符必须相同，其次去掉首尾后的子串也必须是回文串。
2.2 代码实现解析
让我们仔细分析提供的代码实现：
cpp复制class Solution {
public:
string longestPalindrome(string s) {
int n = s.length();
int st = 0; // 记录最长回文子串的起始位置
int maxlen = 1; // 记录最长回文子串的长度，初始为1（单个字符）
// 初始化动态规划表
vector<vector<bool>> f;
for(int i = 0; i < n; i++) {
vector<bool> row(n, false);
f.push_back(row);
}
// 单个字符都是回文串
for(int i = 0; i < n; i++) {
f[i][i] = true;
}
// 从长度为2的子串开始检查
for(int len = 2; len <= n; len++) {
for(int i = 0; i <= n - len; i++) {
int j = i + len - 1;
if(s[i] != s[j]) continue; // 首尾不等，直接跳过
if(len > 2 && !f[i+1][j-1]) continue; // 内部不是回文，跳过
st = i; // 更新起始位置
maxlen = len; // 更新最大长度
f[i][j] = true;
}
}
return s.substr(st, maxlen);
}
};
2.3 算法复杂度分析
- 时间复杂度：O(n²)，因为我们需要填充一个n×n的二维表格
- 空间复杂度：O(n²)，用于存储动态规划表
虽然这个解法已经比暴力法优化了很多，但对于特别长的字符串（比如长度超过10000），空间消耗可能会成为问题。这时可以考虑使用中心扩展法，将空间复杂度降到O(1)。
3. 中心扩展法详解
3.1 中心扩展法思路
中心扩展法的核心思想是：每个回文串都有一个中心，我们可以枚举所有可能的中心，然后向两边扩展，直到字符不相等为止。需要注意的是，回文串的中心可能是单个字符（如"aba"），也可能是两个相同的字符（如"abba"）。
3.2 中心扩展法实现
cpp复制class Solution {
public:
string longestPalindrome(string s) {
if(s.empty()) return "";
int start = 0, end = 0;
for(int i = 0; i < s.length(); i++) {
int len1 = expandAroundCenter(s, i, i); // 奇数长度
int len2 = expandAroundCenter(s, i, i + 1); // 偶数长度
int len = max(len1, len2);
if(len > end - start) {
start = i - (len - 1) / 2;
end = i + len / 2;
}
}
return s.substr(start, end - start + 1);
}
int expandAroundCenter(const string& s, int left, int right) {
while(left >= 0 && right < s.length() && s[left] == s[right]) {
left--;
right++;
}
return right - left - 1;
}
};
3.3 算法复杂度分析
- 时间复杂度：O(n²)，虽然有双重循环，但实际扩展的总次数是线性的
- 空间复杂度：O(1)，只需要常数级别的额外空间
4. Manacher算法（线性时间解法）
4.1 Manacher算法简介
Manacher算法可以在O(n)时间内解决最长回文子串问题。它的核心思想是利用回文串的对称性质，避免重复计算。
4.2 Manacher算法实现
cpp复制class Solution {
public:
string longestPalindrome(string s) {
// 预处理字符串，插入特殊字符
string t = "#";
for(char c : s) {
t += c;
t += '#';
}
int n = t.size();
vector<int> p(n, 0); // 记录每个字符为中心的最长回文半径
int center = 0, right = 0;
int max_len = 0, start = 0;
for(int i = 1; i < n - 1; i++) {
// 利用对称性快速计算初始半径
if(i < right) {
p[i] = min(right - i, p[2 * center - i]);
}
// 中心扩展
while(i - p[i] - 1 >= 0 && i + p[i] + 1 < n &&
t[i - p[i] - 1] == t[i + p[i] + 1]) {
p[i]++;
}
// 更新最右边界和中心
if(i + p[i] > right) {
center = i;
right = i + p[i];
}
// 记录最长回文子串
if(p[i] > max_len) {
max_len = p[i];
start = (i - p[i]) / 2;
}
}
return s.substr(start, max_len);
}
};
4.3 算法复杂度分析
- 时间复杂度：O(n)，每个字符最多被处理两次
- 空间复杂度：O(n)，用于存储半径数组和处理后的字符串
5. 实际应用中的选择与优化
5.1 不同场景下的算法选择
- 短字符串（n < 1000）：动态规划或中心扩展法都可以
- 中等长度字符串（1000 < n < 10000）：中心扩展法更优
- 超长字符串（n > 10000）：Manacher算法是唯一选择
5.2 常见错误与调试技巧
-
边界条件处理：
- 空字符串
- 全相同字符的字符串
- 整个字符串本身就是回文的情况
-
动态规划实现中的常见错误：
- 忘记初始化对角线
- 循环顺序错误（应该按子串长度递增）
- 更新最大长度时遗漏某些情况
-
中心扩展法中的常见错误：
- 忘记处理偶数长度的情况
- 扩展时超出字符串边界
- 计算起始位置时出错
5.3 性能优化建议
-
对于动态规划解法：
- 可以使用滚动数组优化空间复杂度到O(n)
- 提前终止不必要的计算
-
对于中心扩展法：
- 可以记录已经找到的最大长度，提前终止不可能更长的扩展
- 并行处理不同的中心点（在多核环境下）
-
对于Manacher算法：
- 预处理步骤可以优化
- 半径数组可以使用更紧凑的表示方法
6. 扩展思考与实际应用
6.1 回文问题的变种
- 最长回文子序列（不要求连续）
- 分割字符串使每个子串都是回文
- 统计所有回文子串的数量
- 最短回文插入（使任意字符串变为回文）
6.2 实际应用场景
- DNA序列分析：寻找具有特定对称性的序列
- 文本处理：检测回文结构的诗歌或文字游戏
- 密码学：某些加密算法利用回文性质
- 数据压缩：利用回文的重复特性进行压缩
6.3 算法竞赛中的技巧
- 预处理字符串可以简化边界条件处理
- 结合哈希可以快速比较子串是否相同
- 二分答案法可以用于某些变种问题
- 后缀自动机等高级数据结构也能解决这类问题
在实际编码面试中，建议优先实现中心扩展法，因为它既容易理解，又有不错的性能。如果面试官要求更优的解法，再考虑解释Manacher算法。动态规划解法虽然直观，但在空间复杂度上不占优势，适合作为理解问题的起点。