LeetCode 热题 HOT 100 - 5. 最长回文子串

子串：原始字符串的一个连续子集

子序列：原始字符串的一个子集

思路1：动态规划

回文串是天然具有状态转移性质的，这是因为一个回文去掉两头以后，剩下的部分依然是回文。回文的长度要严格大于2。如果一个子串两头的字符不相等，一定不是回文串。如果一个子串两头的字符相等，需要看去掉两头以后剩下部分的子串是否是回文。

——时间复杂度：O(n^2)，其中 n 是字符串的长度。动态规划的状态总数为 O(n^2)，对于每个状态，我们需要转移的时间为 O(1)。

——空间复杂度：O(n^2)，即存储动态规划状态需要的空间。

class Solution {
    public String longestPalindrome(String s) {
        //动态规划
        int len = s.length();
        if(len < 2){
            return s;
        }
        //最长回文子串的起始下标和它的长度
        int maxLen = 1; 
        int begin = 0;
        //dp[i][j]表示s[i..j]是否是回文串
        boolean[][] dp = new boolean[len][len];
        for(int i = 0; i< len;i++){
            dp[i][i]=true;
        }
        char[] charArray = s.toCharArray();
        for(int j=1;j<len;j++){
            for(int i=0;i<j;i++){
                if(charArray[i]!=charArray[j]){
                    dp[i][j]=false;
                }else{
                    if(j-i<3){
                        dp[i][j]=true;
                    }else{
                        dp[i][j]=dp[i+1][j-1];
                    }
                }
                //只要dp[i][j]==true成立,就表示s[i..j]是回文，此时记录回文长度和起始位置
                if(dp[i][j] && j-i+1>maxLen){
                    maxLen = j-i+1;
                    begin = i;
                }
            }
        }
        //这个方法截取的字符串左闭右开
        return s.substring(begin,begin+maxLen);
    }
}

思路2：中心扩散法

遍历每一个索引，以这个索引为中心，利用“回文串”中心对称的特点，往两边扩散，看最多能扩散多远。

——时间复杂度：O(n^2)，其中 n 是字符串的长度。长度为 1 和 2 的回文中心分别有 n 和 n−1 个，每个回文中心最多会向外扩展 O(n) 次。

——空间复杂度：O(1)。

public class Solution {

    public String longestPalindrome(String s) {
        int len = s.length();
        if (len < 2) {
            return s;
        }
        int maxLen = 1;
        String res = s.substring(0, 1);
        // 中心位置枚举到 len - 2 即可
        for (int i = 0; i < len - 1; i++) {
            String oddStr = centerSpread(s, i, i);
            String evenStr = centerSpread(s, i, i + 1);
            String maxLenStr = oddStr.length() > evenStr.length() ? oddStr : evenStr;
            if (maxLenStr.length() > maxLen) {
                maxLen = maxLenStr.length();
                res = maxLenStr;
            }
        }
        return res;
    }

    private String centerSpread(String s, int left, int right) {
        // left = right 的时候，此时回文中心是一个字符，回文串的长度是奇数
        // right = left + 1 的时候，此时回文中心是一个空隙，回文串的长度是偶数
        int len = s.length();
        int i = left;
        int j = right;
        while (i >= 0 && j < len) {
            if (s.charAt(i) == s.charAt(j)) {
                i--;
                j++;
            } else {
                break;
            }
        }
        // 这里要小心，跳出 while 循环时，恰好满足 s.charAt(i) != s.charAt(j)，因此不能取 i，不能取 j
        return s.substring(i + 1, j);
    }
}

思路3：Manacher 算法

参考https://leetcode-cn.com/problems/longest-palindromic-substring/solution/zui-chang-hui-wen-zi-chuan-by-leetcode-solution/