leetcode - 5. Longest Palindromic Substring

Description

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

Example 1:

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

Example 2:

Input: "cbbd"
Output: "bb"

所谓回文子串，指的是正读反读都一致的子串。

solution 1

既然正读反读都一致，那么把字符串反转过来，回文子串也会出现在反转后的字符串里面，且在相对的位置。

show code:

    public String longestPalindrome(String s) {
        if (s.length() == 0) {
            return "";
        }
        int len = s.length();
        int longest = 1, start = 0, end = 1;
        String reverse = new StringBuffer(s).reverse().toString();
        for (int i = 1; i < len; i++) {
            for (int j = 0; j < i; j++) {
                int length = i - j + 1;
                if (reverse.indexOf(s.substring(j, i + 1)) == (len - i - 1)) {
                    if (longest < length) {
                        longest = length;
                        start = j;
                        end = i + 1;
                    }
                }
            }
        }
        return s.substring(start, end);
    }

时间复杂度：看起来时间复杂度像是，但是其实字符串的indexOf方法时间复杂度不是，所以时间复杂度其实是，而且substring还会创建String对象。

空间复杂度：。

提交代码:

leetcode提交结果

果真差的可以。

solution 2

根据回文子串的定义，可以发现如果某个子串是回文子串，那么它的特征是中心对称。如果回文子串的长度是奇数，那么它以中心元素对称；如果回文子串的长度是偶数，那么它以中心的间隙对称，所以一共有个对称中心。

据此，可以遍历每一个中心，找出以此中心对称的最长的子串。

show code:

    public String longestPalindrome(String s) {
        int len = s.length();
        if (len == 0) {
            return s;
        }
        int longest = 0, start = 0, end = 1;
        int count = (len << 1) - 1;
        int left = 0, right = 0;
        for (int i = 1; i < count; i++) {
            left = (i >> 1) + (i & 1) - 1;
            right = left + 2 - (i & 1);
            while (left >= 0 && right < len) {
                if (s.charAt(left) != s.charAt(right)) {
                    break;
                }
                right++;
                if (longest < (right - left)) {
                    longest = right - left;
                    start = left;
                    end = right;
                }
                left--;
            }
            
        }
        return s.substring(start, end);
    }

时间复杂度：。

空间复杂度：。

提交代码:

leetcode提交结果

基于该思路，leetcode提供了一个更高效一点的实现：

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

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

leetcode提交结果

solution 3

在leetcode上，提示了一种解决方案：Manacher's Algorithm。

There is even an algorithm called Manacher's algorithm, explained here in detail. However, it is a non-trivial algorithm, and no one expects you to come up with this algorithm in a 45 minutes coding session. But, please go ahead and understand it, I promise it will be a lot of fun.

看了一下Manacher's Algorithm文章。

首先是解决子串长度奇偶性带来的对称点的位置问题。

Manacher算法首先对字符串做一个预处理，在所有的空隙位置(包括首尾)插入同样的符号，要求这个符号是不会在原串中出现的。这样会使得所有的串都是奇数长度的。插入的是同样的符号，且符号不存在于原串，因此子串的回文性不受影响，原来是回文的串，插完之后还是回文的，原来不是回文的，依然不会是回文。

例如：

abba ———>  #a#b#b#a#

后面的操作都基于预处理后的新字符串。

其次，利用之前的计算，避免重复计算。

为了能利用已经扫描过的信息，我们需要把扫描出来的回文子串记录起来，引入一个辅助变量，表示当前访问到的所有回文子串所能触及的最右一个字符的位置。再用表示对应的回文串的对称轴所在的位置，它们的位置关系如下。

再引入一个回文半径的概念，代表回文串中最左或最右位置的字符与其对称轴的距离称为回文半径。然后利用数组来存储每一个对称点的回文半径。那么求解了该数组便可以求得最长回文子串（因为在每个字符之间插入了一个字符，所以以为对称的最长回文子串=）。

于是问题变成了，怎样高效地求解数组，接下的是求解方法时间复杂度为的关键，方法利用已经扫描过的回文子串来减少计算。

我们利用回文子串的对称性，可以有以下结论：

我们从左向右遍历所有的对称点，当遍历到对称点落在某个回文子串内时，
1）如果以为对称点的回文子串最左端大于外部回文子串的最左端时，那么。

此时。

2）如果以为对称点的回文子串最左端等于外部回文子串的最左端时，那么。

此时。

3）如果以为对称点的回文子串最左端小于外部回文子串的最左端时，那么。

此时。

所以当时，我们有：。

show code:

    public static String longestPalindrome(String s) {
        int len = s.length();
        if (len == 0) {
            return s;
        }
        int count = len << 1;
        int radius[] = new int[count];
        int mr = 2, id = 1;
        int longest = 1, longestId = 1;
        int left = 0, right = 0;
        for (int i = 2; i < count - longest; i++) {
            radius[i] = mr > i ? Math.min(radius[(id << 1) - i], mr - i) : 1;
            left = (i - radius[i] - 1) >> 1;
            right = (i + radius[i]) >> 1;
            while (left >= 0 && right < len) {
                if (s.charAt(left) != s.charAt(right)) {
                    break;
                }
                radius[i] = right - left + 1;
                right++;
                left--;
            }
            if (radius[i] + i > mr && radius[i] != 1) {
                mr = radius[i] + i;
                id = i;
            }
            if (radius[i] > longest) {
                longest = radius[i];
                longestId = i;
            }
        }
        return s.substring((longestId - longest + 1) >> 1, ((longestId - longest + 1) >> 1) + longest);
    }

时间复杂度：虽然算法中有两个循环，但是时间复杂度却是，这是因为：

如果情况符合结论一或三，那么只要判断一次便会打破内层循环。

如果情况符合结论二，那么内层循环每次都会扫描之前未扫描过的字符，直到打破循环。

空间复杂度：。

提交代码: