LeetCode 5. 最长回文子串：从暴力到Manacher的全语言实战指南

回文串问题一直是算法领域的经典课题，而寻找最长回文子串更是LeetCode等编程平台的热门题目。本文将带您从最基础的暴力解法出发，逐步深入探讨中心扩展算法，最终掌握被誉为"回文串处理终极武器"的Manacher算法。不同于普通的算法教程，我们将提供Python、Java和C++三种语言的完整实现，并分析每种解法的适用场景和优化技巧。

1. 问题定义与暴力解法

回文串是指正读反读都相同的字符串，比如"madam"、"racecar"。最长回文子串问题要求我们在给定字符串中找到最长的连续回文子序列。

1.1 暴力解法思路

最直观的解决方法是检查所有可能的子串：

python复制def is_palindrome(s, left, right):
    while left < right:
        if s[left] != s[right]:
            return False
        left += 1
        right -= 1
    return True

def longestPalindrome_brute(s: str) -> str:
    n = len(s)
    if n < 2:
        return s
    
    max_len = 1
    start = 0
    for i in range(n):
        for j in range(i+1, n):
            if j-i+1 > max_len and is_palindrome(s, i, j):
                max_len = j-i+1
                start = i
    return s[start:start+max_len]

复杂度分析：

• 时间复杂度：O(n³) - 两层循环枚举所有子串O(n²)，每个子串检查回文O(n)
• 空间复杂度：O(1)

1.2 暴力解法的局限性

当字符串长度达到1000时，暴力解法显然无法在合理时间内完成。我们需要更高效的算法。

2. 中心扩展算法：O(n²)的优雅解法

中心扩展算法通过枚举所有可能的回文中心，向两侧扩展寻找最长回文，显著降低了时间复杂度。

2.1 算法核心思想

回文中心有两种情况：

1. 单个字符作为中心（奇数长度回文）
2. 两个相同字符作为中心（偶数长度回文）

java复制class Solution {
    public String longestPalindrome(String s) {
        if (s == null || s.length() < 1) 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 = Math.max(len1, len2);
            if (len > end - start) {
                start = i - (len - 1) / 2;
                end = i + len / 2;
            }
        }
        return s.substring(start, end + 1);
    }
    
    private int expandAroundCenter(String s, int left, int right) {
        while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
            left--;
            right++;
        }
        return right - left - 1;
    }
}

2.2 复杂度与优化

复杂度分析：

• 时间复杂度：O(n²) - 枚举n个中心，每个中心最多扩展n次
• 空间复杂度：O(1)

实际应用中的优化技巧：

1. 提前终止：当剩余长度不可能超过当前最大值时提前结束
2. 中心选择策略：从中间开始扩展可能更快找到大回文

3. Manacher算法：线性时间的终极方案

Manacher算法通过巧妙预处理和动态规划思想，将时间复杂度降至O(n)，是处理回文问题的黄金标准。

3.1 算法核心概念

关键预处理：在字符间插入特殊字符（如#），统一奇偶情况

code复制原字符串: "abba" → 预处理后: "#a#b#b#a#"

核心变量：

• p[i]：以i为中心的最长回文半径
• C：当前最大回文的中心
• R：当前最大回文的右边界

3.2 完整C++实现

cpp复制class Solution {
public:
    string longestPalindrome(string s) {
        string T = preprocess(s);
        int n = T.length();
        vector<int> P(n, 0);
        int C = 0, R = 0;
        
        for (int i = 1; i < n-1; i++) {
            int mirror = 2*C - i; // C - (i - C)
            
            if (i < R) {
                P[i] = min(R - i, P[mirror]);
            }
            
            // 尝试扩展
            while (T[i + (1 + P[i])] == T[i - (1 + P[i])]) {
                P[i]++;
            }
            
            // 更新中心和右边界
            if (i + P[i] > R) {
                C = i;
                R = i + P[i];
            }
        }
        
        // 找出最大回文
        int max_len = 0;
        int center = 0;
        for (int i = 1; i < n-1; i++) {
            if (P[i] > max_len) {
                max_len = P[i];
                center = i;
            }
        }
        
        return s.substr((center - max_len)/2, max_len);
    }
    
private:
    string preprocess(string s) {
        if (s.empty()) return "^$";
        string ret = "^";
        for (char c : s) {
            ret += "#";
            ret += c;
        }
        ret += "#$";
        return ret;
    }
};

3.3 算法复杂度分析

时间复杂度：O(n) - 每个字符最多被处理一次
空间复杂度：O(n) - 需要存储p数组

4. 多语言实现对比与性能测试

4.1 三种语言实现特点

4.2 实际性能测试数据

我们对三种算法在不同长度字符串上的表现进行了测试（单位：ms）：

提示：实际编程竞赛中，当n≤1000时中心扩展算法通常足够，但面对更大数据规模时Manacher算法优势明显

5. 算法选择与实战技巧

5.1 如何选择合适的算法

1. 小规模数据（n≤100）：暴力解法可能更易实现
2. 中等规模（100<n≤5000）：中心扩展算法平衡了效率和实现难度
3. 大规模数据（n>5000）：必须使用Manacher算法

5.2 LeetCode提交技巧

• 预处理优化：提前处理空串和单字符情况
• 边界条件：注意字符串全相同或全不同的极端情况
• 内存管理：C++实现中避免不必要的字符串拷贝

python复制# Python优化版中心扩展
def longestPalindrome(s: str) -> str:
    if not s or len(s) < 1:
        return ""
    
    def expand(l, r):
        while l >= 0 and r < len(s) and s[l] == s[r]:
            l -= 1
            r += 1
        return r - l - 1
    
    start, end = 0, 0
    for i in range(len(s)):
        len1 = expand(i, i)
        len2 = expand(i, i+1)
        max_len = max(len1, len2)
        if max_len > end - start:
            start = i - (max_len - 1) // 2
            end = i + max_len // 2
    
    return s[start:end+1]

5.3 常见错误与调试

1. Manacher算法预处理错误：忘记处理字符串边界
2. 中心扩展边界条件：偶数长度回文处理不当
3. 索引越界：特别是在C++中要小心字符串访问

在解决LeetCode第5题时，我最初尝试直接实现Manacher算法却遇到了各种边界问题。后来发现先掌握中心扩展算法，再逐步过渡到Manacher是更有效的学习路径。实际编码时，建议先用小例子（如"babad"）手动模拟算法过程，确保理解每个变量的含义。