5. 最长回文子串

一、问题

给你一个字符串 s，找到 s 中最长的回文子串。

二、解题思路

解决最长回文子串问题的常见方法之一是中心扩展算法。这种方法利用了回文的对称性质：以每个字符为中心向两边扩展，找到最长的回文子串。

思路：

1. 每个字符和每两个字符之间的间隙都可以作为回文中心。
2. 从中心向两侧扩展字符，检查扩展后的子串是否是回文。
3. 记录最长的回文子串。

由于回文可能是奇数长度（以单个字符为中心）或者偶数长度（以两个字符中间的间隙为中心），我们需要分别考虑这两种情况。

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);
    }

    // 辅助方法，以 left 和 right 为中心向两侧扩展，寻找回文
    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;
    }
}

该算法的时间复杂度是 O(n²)，其中 n 是字符串的长度。虽然时间复杂度不是最优的，但其空间复杂度是 O(1)（不考虑返回值的空间）

动态规划法的思路：

1. 用一个二维数组 dp 来表示子串是否为回文。dp[i][j] 表示从字符串的第 i 个字符到第 j 个字符的子串是否是回文子串。
2. 动态规划的状态转移方程为：
   • 如果 s[i] == s[j] 并且 j - i <= 2（也就是子串长度小于等于 3），那么 dp[i][j] = true，表示当前子串是回文。
   • 如果 s[i] == s[j] 并且 dp[i+1][j-1] == true，那么 dp[i][j] = true，表示当前子串是回文。
3. 每次更新 dp[i][j] 时，如果当前子串是回文，记录下最长的回文子串的起始和结束位置。

class Solution {
    public String longestPalindrome(String s) {
        int n = s.length();
        if (n < 2) {
            return s; // 如果字符串长度小于 2，直接返回字符串本身
        }

        // dp[i][j] 表示 s[i...j] 是否是回文子串
        boolean[][] dp = new boolean[n][n];
        int start = 0, maxLen = 1; // 初始化最长回文子串的起始位置和长度

        // 单个字符的子串都是回文
        for (int i = 0; i < n; i++) {
            dp[i][i] = true;
        }

        // 遍历所有长度大于1的子串
        for (int len = 2; len <= n; len++) { // 子串长度从 2 开始
            for (int i = 0; i < n - len + 1; i++) { // i 是子串的起点
                int j = i + len - 1; // j 是子串的终点
                
                if (s.charAt(i) == s.charAt(j)) {
                    if (len == 2 || dp[i + 1][j - 1]) { // 判断是否回文
                        dp[i][j] = true;

                        // 如果找到更长的回文子串，更新起始位置和最大长度
                        if (len > maxLen) {
                            start = i;
                            maxLen = len;
                        }
                    }
                }
            }
        }

        // 返回最长回文子串
        return s.substring(start, start + maxLen);
    }
}

时间复杂度：
动态规划的时间复杂度为 O(n²)，其中 n 是字符串的长度。空间复杂度也是 O(n²)，因为需要存储一个二维的动态规划表 dp。
虽然时间复杂度是 O(n²)，但对于中等长度的字符串来说，这种方法在实践中表现不错，而且代码清晰易于理解。