最长回文子串 Longest Palindromic Substring

2019独角兽企业重金招聘Python工程师标准>>>

问题：

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

Example:

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

Example:

Input: "cbbd"
Output: "bb"

① 暴力循环。遍历字符串S的每一个子串，去判断这个子串是不是回文，是回文的话看看长度是不是比最大的长度maxlength大。遍历每一个子串的方法要O（n^2），判断每一个子串是不是回文的时间复杂度是O(n)，所以暴利方法的总时间复杂度是O（n^3）。。。。超时。

public class Solution {
    public String longestPalindrome(String s) {
        int maxLength = 0;
        int start = 0;
        int len = s.length();
        //i是字符串长度
        for(int i = 0; i < len; i ++){
            //j是字符串起始位置
            for(int j = 0; j < len - i; j ++){
                //挨个判断是否回文
                if(isPalindrome(s,i,j) && (i + 1) > maxLength){
                    maxLength = i + 1;
                    start = j;
                }
            }
        }
        return s.substring(start,start + maxLength);
    }
    public boolean isPalindrome(String s, int i, int j){//i是长度，j是起始位置
        int left = j;
        int right = j + i;
        while(left < right){
            if(s.charAt(left) != s.charAt(right)){
                return false;
            }
            left ++;
            right --;
        }
        return true;
    }
}

② 根据回文的特性，一个大回文按比例缩小后的字符串也必定是回文，比如ABCCBA，那BCCB肯定也是回文。所以我们可以根据动态规划的两个特点：第一大问题拆解为小问题，第二重复利用之前的计算结果，来解答这道题。
那如何划分小问题呢：

1) 数组dp[i][j]记录s从i到j是不是回文。dp[i][j]=false:表示子串[i,j]不是回文串。dp[i][j]=true:表示子串[i,j]是回文串。
2) 初始化：i == j时，dp[i][j] = true,此时字符串s是单字符的回文。
3) 状态转移方程：dp[i][j]=true:当且仅当s1[i] == s1[j] && (j - i < 2 || dp[i + 1][j - 1])时间复杂度为O（n^2）

class Solution { //89ms
    public String longestPalindrome(String s) {
        int len = s.length();
        boolean[][] dp = new boolean[len][len];
        char[] s1 = s.toCharArray();
        int maxlen = 1;
        int start = 0;
        for (int i = 0; i < len; i++) {
            dp[i][i] = true;
            for (int j = 0; j < i; j++) {
                dp[j][i] = (s1[i] == s1[j] && (i - j < 2 || dp[j + 1][i - 1]));
                if (dp[j][i] && maxlen < i - j + 1) {
                    maxlen = i - j + 1;
                    start = j;
                }
            }
        }
        return s.substring(start, start + maxlen);
    }
}

③ 对于找回文字串的问题，就要以每一个字符为中心，向两边扩散来寻找回文串，这个算法的时间复杂度是O(n*n)，要注意奇偶情况，由于回文串的长度可奇可偶，比如"bob"是奇数形式的回文，"noon"就是偶数形式的回文，两种形式的回文都要搜索。

public class Solution { //18ms
    int low;
    int maxLen;
    public String longestPalindrome(String s) {
        int len = s.length();
        if (len < 2) return s;
        for (int i = 0; i < len;i ++) {
            validPalindrome(s, i, i); //odd
            validPalindrome(s,i,i + 1); //even
        }
        return s.substring(low, low + maxLen);
    }
    public void validPalindrome(String s, int left, int right) {
        while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
            left --;
            right ++;
        }
        if (right - left - 1 > maxLen) {
            maxLen = right - left - 1;
            low = left + 1;
        }
    }
}

④ Manacher’s Algorithm (马拉车算法)

---- http://www.cnblogs.com/bitzhuwei/p/Longest-Palindromic-Substring-Part-II.html#_label1

首先我们把字符串S改造一下变成T，改造方法是：在S的每个字符之间和S首尾都插入一个"#"。这样做的理由你很快就会知道。

例如，S="abaaba"，那么T="#a#b#a#a#b#a#"。

想一下，你必须在以Ti为中心左右扩展才能确定以Ti为中心的回文长度d到底是多少。（就是说这一步是无法避免的）

为了改进最坏的情况，我们把各个Ti处的回文半径存储到数组P，用P[i]表示以Ti为中心的回文长度。那么当我们求出所有的P[i]，取其中最大值就能找到最长回文子串了。

对于上文的示例，我们先直接写出所有的P研究一下。

i = 0 1 2 3 4 5 6 7 8 9 A B C

T = # a # b # a # a # b # a #

P = 0 1 0 3 0 1 6 1 0 3 0 1 0

显然最长子串就是以P[6]为中心的"abaaba"。

你是否发现了，在插入"#"后，长度为奇数和偶数的回文都可以优雅地处理了？这就是其用处。

现在，想象你在"abaaba"中心画一道竖线，你是否注意到数组P围绕此竖线是中心对称的？再试试"aba"的中心，P围绕此中心也是对称的。这当然不是巧合，而是在某个条件下的必然规律。我们将利用此规律减少对数组P中某些元素的重复计算。

我们来看一个重叠得更典型的例子，即S="babcbabcbaccba"。

 

上图展示了把S转换为T的样子。假设你已经算出了一部分P。竖实线表示回文"abcbabcba"的中心C，两个虚实线表示其左右边界L和R。你下一步要计算P[i]，i围绕C的对称点是i’。你有办法高效地计算P[i]吗？

我们先看一下i围绕C的对称点i’（此时i’=9）。

 

据上图所示，很明显P[i]=P[i’]=1。这是因为i和i’围绕C对称。同理，P[12]=P[10]=0，P[14]=P[8]=0。

 

现在再看i=15处。此时P[15]=P[7]=7？错了，你逐个字符检测一下会发现此时P[15]应该是5。

为什么此时规则变了？

 

如上图所示，两条绿色实线划定的范围必定是对称的，两条绿色虚线划定的范围必定也是对称的。此时请注意P[i’]=7，超过了左边界L。超出的部分就不对称了。此时我们只知道P[i]>=5，至于P[i]还能否扩展，只有通过逐个字符检测才能判定了。

在此例中，P[21]≠P[9]，所以P[i]=P[15]=5。

我们总结一下上述分析过程，就是这个算法的关键部分了。

if P[ i' ] < R – i, then P[ i ] ← P[ i' ] else P[ i ] ≥ R - i. (此时要穿过R逐个字符判定P[i]).

（注：原作者的写法在逻辑上欠妥，我作了修正）

是不是很优雅？如果你能理解到这里，你已经搞定了这个算法最困难也最精华的部分了。

很明显C的位置也是需要移动的，这个很容易：

如果i处的回文超过了R，那么就C=i，同时相应改变L和R即可。

每次求P[i]，都有两种可能。如果P[i‘] < R – i，我们就P[i] = P[i’]。否则，就从R开始逐个字符求P[i]，并更新C及其R。此时扩展R（逐个字符求P[i]）最多用N步，而求每个C也总共需要N步。所以时间复杂度是2*N，即O(N)。

（注：原作者计算时间复杂度的这句话我没看懂。我自己想办法理解了，详情见下图。

图中i为索引，T为加入"#"、"^"和"$"后的字符串，P[i]就是算法里的p[i]，calc[i]是为了求出P[i]而需要执行比较的次数。

"V"表示此列的字符与其左侧的字符进行了比较，在左侧用"X"对应。绿色的表示比较结果为两个字符相同（即比较结果为成功），红色的表示不同（即比较结果为失败）。

很显然"X"和"V"的数量是相等的。

你可以看到，所需的成功比较的次数（绿色的"V"，表现为横向增长）不超过N，失败的次数（红色的"V"，表现为纵向增长）也不超过N，所以这个算法的时间复杂度就是2N，即O(N)。

）

public class Solution { //89ms
    // Transform S into T.
    // For example, S = "abba", T = "^#a#b#b#a#$".
    // ^ and $ signs are sentinels appended to each end to avoid bounds checking
    String preProcess(String s) {
        int n = s.length();
        if (n == 0) return "^$";
        String res = "^";
        for (int i = 0; i < n; i ++){
            res += "#" + s.substring(i, i + 1);
        }
        res += "#$";
        return res;
    }
    public String longestPalindrome(String s) {
        String T = preProcess(s);
        int length = T.length();
        int[] p = new int[length];
        int C = 0, R = 0;
        for (int i = 1; i < length - 1; i++){
            int i_mirror = C - (i - C);
            int diff = R - i;
            if (diff >= 0){//当前i在C和R之间，可以利用回文的对称属性
                if (p[i_mirror] < diff){ //i的对称点的回文长度在C的大回文范围内部
                    p[i] = p[i_mirror]; 
                }else{
                    p[i] = diff;
                    //i处的回文可能超出C的大回文范围了
                    while (T.charAt(i + p[i] + 1) == T.charAt(i - p[i] - 1)){ 
                        p[i] ++; 
                    }
                    C = i;
                    R = i + p[i];
                }
            }else{
                p[i] = 0;
                while (T.charAt(i + p[i] + 1) == T.charAt(i - p[i] - 1)){ 
                    p[i] ++; 
                }
                C = i;
                R = i + p[i];
            }
        }
        int maxLen = 0;
        int centerIndex = 0;
        for (int i = 1; i < length - 1; i ++) {
            if (p[i] > maxLen) {
              maxLen = p[i];
              centerIndex = i;
            }
        }
        return s.substring((centerIndex - 1 - maxLen) / 2, (centerIndex - 1 - maxLen) / 2 + maxLen);     
    }
}

转载于:https://my.oschina.net/liyurong/blog/1523341