5. Longest Palindromic Substring [Medium] 最长回文子串（Manacher不懂）

Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为 1000。

Example 1:

Input: "babad"
Output: "bab"
Note: "aba" is also a valid answer.

Example 2:

Input: "cbbd"
Output: "bb"

方法一：最长公共子串

常见错误：找到字符串 S 与 反转的S 最长的公共子串，认为这是最长回文串。比如 S="caba"，可以找到 aba 是答案。但是，当 S="abcdefdcba", 找到 abcd, 这并不是回文串。

所以，当 SS 的其他部分中存在非回文子串的反向副本时，最长公共子串法就会失败。为了纠正这一点，每当我们找到最长的公共子串的候选项时，都需要检查子串的索引是否与反向子串的原始索引相同。如果相同，那么我们尝试更新目前为止找到的最长回文子串；如果不是，我们就跳过这个候选项并继续寻找下一个候选。

方法二：暴力法

将选出所有子字符串可能的开始和结束位置，并检验它是不是回文。

复杂度：

• 时间：O(n^3)
• 空间：O(1)

方法三：动态规划

动态规划（Dynamic Programming，DP）是一种用来解决一类最优化问题的算法思想。简单来说，DP就是将一个复杂问题分为若干个子问题，通过综合子问题的最优解来得到原问题的最优解。值得注意的是，DP 会将每个求解过程中求解过的子问题的解记录下来，这样下一次遇到同样的子问题，就可以用之前记录的结果，而不是重复计算。

这里我们把长度 1 和 2 作为DP问题分边界，如果 S[i+1,j-1]是回文串，那么只要 S[ i ] == S[ j ] ，就可以确定 S[i,j]也是回文串了。

求 长度为 1 和长度为 22的 P(i,j)时不能用上边的公式，因为我们代入公式后会遇到 P[i][j]中 i > j 的情况，比如求 P[1][2]的话，我们需要知道 P[1+1][2-1]=P[2][1]，而 P[2][1]代表着 S[2,1] 是不是回文串，显然是不对的，所以我们需要单独判断。

所以我们先初始化长度是 1的回文串的 P [ i , j ]P[i,j]，这样利用上边提出的公式，然后两边向外各扩充一个字符，长度为 3 的，为 5 的，所有奇数长度的就都求出来了。

同理，初始化长度是 2 的回文串 P [ i , i + 1 ]，利用公式，长度为 4 的，6 的所有偶数长度的就都求出来了。

public String longestPalindrome(String s) {
    int length = s.length();
    boolean[][] P = new boolean[length][length];
    int maxLen = 0;
    String maxPal = "";
    for (int len = 1; len <= length; len++) //遍历所有的长度
        for (int start = 0; start < length; start++) {
            int end = start + len - 1;
            if (end >= length) //下标已经越界，结束本次循环
                break;
            P[start][end] = (len == 1 || len == 2 || P[start + 1][end - 1]) && s.charAt(start) == s.charAt(end); //长度为 1 和 2 的单独判断下
            if (P[start][end] && len > maxLen) {
                maxPal = s.substring(start, end + 1);
            }
        }
    return maxPal;
}

复杂度：

• 时间：O(n^2)
• 空间：O(n^2)

方法四：中心扩展算法

我们知道回文串一定是对称的，所以我们可以每次循环选择一个中心，进行左右扩展，判断左右字符是否相等即可。

由于存在奇数的字符串和偶数的字符串，所以我们需要从一个字符开始扩展，或者从两个字符之间开始扩展，所以总共有 n+n-1 个中心。

public String longestPalindrome(String s) {
    if (s == null || s.length() < 1) return "";
    int start = 0;  //记录回文串开始位置
    int 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) {
    int L = left, R = right;
    while (L >= 0 && R < s.length() && s.charAt(L) == s.charAt(R)) {
        L--;
        R++;
    }
    return R - L - 1;
}

复杂度：

• 时间：O(n^2)
• 空间：O(1)

方法五：Manacher算法 马拉车算法（看不懂....）

复杂度可以达到线性 O(n)