5.最长回文子串.java中等(Manacher算法)

Java substring()方法

Java substring()方法：
substring() 方法返回字符串的子字符串
public String substring(int beginIndex)
或
public String substring(int beginIndex, int endIndex)

参数：
beginIndex -- 起始索引（包括）, 索引从 0 开始
endIndex -- 结束索引（不包括）

Java StringBuffer（）

Java StringBuffer 和 StringBuilder 类

当对字符串进行修改的时候，需要使用 StringBuffer 和 StringBuilder 类。

和 String 类不同的是，StringBuffer 和 StringBuilder 类的对象能够被多次的修改，并且不产生新的未使用对象。

StringBuilder 类在 Java 5 中被提出，它和 StringBuffer 之间的最大不同在于 StringBuilder 的方法不是线程安全的（不能同步访问）。

由于 StringBuilder 相较于 StringBuffer 有速度优势，所以多数情况下建议使用 StringBuilder 类。然而在应用程序要求线程安全的情况下，则必须使用 StringBuffer 类。 

https://www.runoob.com/java/java-stringbuffer.html

1.暴力枚举

class Solution {
    public String longestPalindrome(String s) {
        String ans = "";
        int max  = 0;
        int len = s.length();
        for (int i = 0; i < len; i++){
            for (int j = i+1; j <= len; j++){
                String test = s.substring(i,j);
                if(isPalindromic(test) && test.length() > max){
                    ans = test;
                    max = test.length();
                }
            }
        }
        return ans;
    }

    public boolean isPalindromic(String s){
        int len = s.length();
        for (int i = 0; i < len/2; i++){
            if (s.charAt(i) != s.charAt(len-i-1))
                return false;
        }
        return true;
    }
}

2.暴力破解优化

第11行核心代码

class Solution {
    public String longestPalindrome(String s) {
        int length = s.length();
        boolean[][] P = new boolean[length][length];
        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);
                if (P[start][end] == true ){
                    maxPal = s.substring(start,end+1);
                }
            }
        }
        return maxPal;
    }
}

 

 

3.扩展中心

class Solution {
    public String longestPalindrome(String s) {
        if (s.length()==0) return "";
        int start = 0, end = 0;
        for (int i = 0; i<s.length(); i++){
            int len1 = expandArroundCenter(s,i,i);
            int len2 = expandArroundCenter(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);   
    }
    public int expandArroundCenter(String s, int left, int right){
        int L = left;
        int R = right;
        while(L >= 0 && R < s.length() && s.charAt(L) == s.charAt(R)){
            L --;
            R ++;
        }
        return R-L-1;
    }
}

4.Manacher算法

class Solution {
    public String longestPalindrome(String s) {
        String T = preProcess(s);
        int len =  T.length();
        int[] P = new int[len];
        int C = 0, R = 0;
        for ( int i = 1; i < len-1; i++){//从1开始，忽略字符串首的"^"
            int i_mirror = 2*C-i;
            if (R > i){
                P[i] = Math.min(R-i,P[i_mirror]);
            }else{
                P[i] =0;
            }
            
            while (T.charAt(i+1+P[i]) == T.charAt(i-1-P[i])){
                P[i]++;
            }
            
            if (i+P[i] > R){
                C = i;
                R = i + P[i];
            }
        }

        int maxlen = 0;
        int centerIndex = 0;
        for (int i = 1; i < len-1; i++){
            if (P[i] > maxlen){
                maxlen = P[i];
                centerIndex = i;
            }
        }

        int start = (centerIndex - maxlen)/2;
        return s.substring(start,start+maxlen);
    }

    public String preProcess(String s){
        int len = s.length();
        if (len==0)
            return "^$";
        String ret = "^";
        for (int i = 0; i < len; i++)
            ret += "#" + s.charAt(i);
        ret += "#$";
        return ret;
    }
}

首先我们解决下奇数和偶数的问题，在每个字符间插入 "#"，并且为了使得扩展的过程中，到边界后自动结束，在两端分别插入 "^" 和 "$"，两个不可能在字符串中出现的字符，这样中心扩展的时候，判断两端字符是否相等的时候，如果到了边界就一定会不相等，从而出了循环。经过处理，字符串的长度永远都是奇数了。

首先我们用一个数组 P 保存从中心扩展的最大个数，而它刚好也是去掉 "#" 的原字符串的总长度。例如下图中下标是 6 的地方，可以看到 P[ 6 ] 等于 5，所以它是从左边扩展 5 个字符，相应的右边也是扩展 5 个字符，也就是 "#c#b#c#b#c#"。而去掉 # 恢复到原来的字符串，变成 "cbcbc"，它的长度刚好也就是 5。

求原字符串下标

用 P 的下标 i 减去 P [ i ]，再除以 2，就是原字符串的开头下标了。

例如我们找到 P[ i ] 的最大值为 5，也就是回文串的最大长度是 5，对应的下标是 6，所以原字符串的开头下标是（6 - 5 ）/ 2 = 0。所以我们只需要返回原字符串的第 0 到 第（5 - 1）位就可以了。
求每个 P [ i ]

接下来是算法的关键了，它充分利用了回文串的对称性。

我们用 C 表示回文串的中心，用 R 表示回文串的右边半径。所以 R = C + P[ i ]。C 和 R 所对应的回文串是当前循环中 R 最靠右的回文串。

让我们考虑求 P [ i ] 的时候，如下图。

用 i_mirror 表示当前需要求的第 i 个字符关于 C 对应的下标

我们现在要求 P [ i ]，如果是用中心扩展法，那就向两边扩展比对就行了。但是我们其实可以利用回文串 C 的对称性。i 关于 C 的对称点是 i_mirror，P [ i_mirror ] = 3，所以 P [ i ] 也等于 3。

但是有三种情况将会造成直接赋值为 P [ i_mirror ] 是不正确的，下边一一讨论。

1. 超出了 R

当我们要求 P [ i ] 的时候，P [ mirror ] = 7，而此时 P [ i ] 并不等于 7，为什么呢，因为我们从 i 开始往后数 7 个，等于 22，已经超过了最右的 R，此时不能利用对称性了，但我们一定可以扩展到 R 的，所以 P [ i ] 至少等于 R - i = 20 - 15 = 5，会不会更大呢，我们只需要比较 T [ R+1 ] 和 T [ R+1 ]关于 i 的对称点就行了，就像中心扩展法一样一个个扩展。
2. P [ i_mirror ] 遇到了原字符串的左边界

此时P [ i_mirror ] = 1，但是 P [ i ] 赋值成 1 是不正确的，出现这种情况的原因是 P [ i_mirror ] 在扩展的时候首先是 "#" == "#"，之后遇到了 "^" 和另一个字符比较，也就是到了边界，才终止循环的。而 P [ i ] 并没有遇到边界，所以我们可以继续通过中心扩展法一步一步向两边扩展就行了。
3. i 等于了 R

此时我们先把 P [ i ] 赋值为 0，然后通过中心扩展法一步一步扩展就行了。
考虑 C 和 R 的更新

就这样一步一步的求出每个 P [ i ]，当求出的 P [ i ] 的右边界大于当前的 R 时，我们就需要更新 C 和 R 为当前的回文串了。因为我们必须保证 i 在 R 里面，所以一旦有更右边的 R 就要更新 R。

此时的 P [ i ] 求出来将会是 3，P [ i ] 对应的右边界将是 10 + 3 = 13，所以大于当前的 R，我们需要把 C 更新成 i 的值，也就是 10，R 更新成 13。继续下边的循环。

参考：https://leetcode-cn.com/problems/longest-palindromic-substring/solution/xiang-xi-tong-su-de-si-lu-fen-xi-duo-jie-fa-bao-gu/