[LeetCode] 5. Longest Palindromic Substring

Longest Palindromic Substring

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”

解析

求最长回文子串。

解法1

最简单的解法就是暴力搜索，在每一个字符上，分别通过奇数和偶数两种情况向两边扩展，特别的当为偶数时，中间的两个点为当前节点以及下一个节点。
通过一个辅助函数来记录最大长度以及开始节点的位置，这样可以不用存储字符子串。
代码如下：

class Solution {
public:
    string longestPalindrome(string s) {
        if (s.size() < 2) return s;
        int n = s.size(), maxLen = 0, start = 0;
        for (int i = 0; i < n - 1; ++i) {
            searchPalindrome(s, i, i, start, maxLen);
            searchPalindrome(s, i, i + 1, start, maxLen);
        }
        return s.substr(start, maxLen);
    }
    
    void searchPalindrome(string s, int left, int right, int& start, int& maxLen){
        while(left>=0 && right<s.size() && s[left] == s[right]){
            left --;
            right ++;
        }
        if (maxLen < right - left - 1) {
            start = left + 1;
            maxLen = right - left - 1;
        }
    }
};

解法2

不使用子函数，思路同样是找到起始节点以及最大长度。首先判断剩余长度是否小于maxlen的1/2，如果小于可以直接break。
重点是向右遍历跳过重复项，比如对于 noon，i在第一个o的位置，如果我们以o为最中心往两边扩散，是无法得到长度为4的回文串的，只有先跳过重复，此时left指向第一个o，right指向第二个o，然后再向两边扩散。而对于 bob，i在第一个o的位置时，无法向右跳过重复，此时left和right同时指向o，再向两边扩散也是正确的，所以可以同时处理奇数和偶数的回文串，之后的操作就是更新maxLen和start了，跟解法1一样。

class Solution {
public:
    string longestPalindrome(string s) {
        if (s.size() < 2) return s;
        int n = s.size(), maxLen = 0, start = 0;
        int left,right;
        for (int i = 0; i < n;) {
            if(n-i <= maxLen/2) break;
            left = right = i;
            while(right < n-1 && s[right+1] == s[right])
                right ++;
            i = right + 1;
            while(left>0 && right<n-1 && s[left-1] == s[right+1]){
                left --;
                right ++;
            }
            if (maxLen < right - left + 1) {
                start = left;
                maxLen = right - left + 1;
            }
        }
        return s.substr(start, maxLen);
    }
};

解法3：动态规划

利用动态规划来解决这个问题.
首先构建一个二维数组，初始化为0，dp[i][j]表示i和j之间是回文字符串，此时有三种情况：

1. i==j：表示一个字符，肯定为回文串，dp[i][i]=1；
2. i=j+1：相邻的字符，当s[i]==s[j]时，dp[i][j] =1;
3. i>j+1：不相邻字符，当s[i]==s[j]时，并且dp[i-1][j+1]=1时，dp[i][j] =1。

要注意的时，一定要维护一个right值，用right-left+1来表示回文串的长度。不能直接用len来表示字符串的长度，这样是防止回文串只有一个字符的情况。代码如下：

class Solution {
public:
    string longestPalindrome(string s) {
        if (s.empty()) return "";
        int n = s.size();
        int dp[n][n] = {0}, left = 0,right=0,len = 0;
        for (int i = 0; i < n;i++) {
            for(int j=0;j<i;j++){
                dp[j][i] = (s[i] == s[j] && (i-j<2 || dp[j+1][i-1]));
                if(dp[j][i] && len < i-j+1){
                    len = i-j+1;
                    left = j;
                    right = i;
                }
            }
            dp[i][i] = 1;
        }
        return s.substr(left, right-left+1);
    }
};

解法4：马拉车算法（Manacher’s Algorithm）

使用“马拉车算法”可以达到O(n)的时间复杂度，马拉车算法具体步骤参考马拉车算法。
先对字符串进行预处理，在字符之间添加一个#号，如
bob --> #b#o#b#
noon --> #n#o#o#n#
数组len[i]表示以i为中心的最长回文串的半径，如
#1#2#2#1#2#2#
1212521612321
找到规律为：最长子串的长度是半径减1，起始位置是中间位置减去半径再除以2。
计算len数组：
从左到右计算，设P是之前最长回文串的最右端，po是最长回文串的中点，
当i<=p时
找到i关于po对称的位置j，
如果len[j]<p-i：如下图

说明以j为中心的回文串在以po为中心的回文串内部，根据对称，以i为中心的回文串也在内部，并且有len[i] = len[j]；
如果len[j]>=p-i：如下图

说明以i为中心的回文串可能会延申到P外面，所以P外面的需要一个一个匹配，并更新P和po已经len[i];
当i>P时，说明以i为中心的回文串还没有匹配，一个一个匹配。

最重要的一步就是p[i] = mx > i ? min(p[2 * id - i], mx - i) : 1;
如果 mx > i, 则 p[i] = min( p[2 * id - i] , mx - i )
否则，p[i] = 1

class Solution {
public:
    string longestPalindrome(string s) {
        string t ="$#";
        for (int i = 0; i < s.size(); ++i) {
            t += s[i];
            t += '#';
        }
        int p[t.size()] = {0}, id = 0, mx = 0, resId = 0, resMx = 0;
        for (int i = 0; i < t.size();i++) {
            p[i] = mx > i ? min(p[2 * id - i], mx - i) : 1;
            while (t[i + p[i]] == t[i - p[i]]) 
            	++p[i];
            if (mx < i + p[i]) {
                mx = i + p[i];
                id = i;
            }
            if (resMx < p[i]) {
                resMx = p[i];
                resId = i;
            }
        }
        return s.substr((resId - resMx) / 2, resMx - 1);
    }
};

参考

http://www.cnblogs.com/grandyang/p/4464476.html
http://www.cnblogs.com/grandyang/p/4475985.html
https://blog.csdn.net/liuwei0604/article/details/50414542
https://blog.csdn.net/dyx404514/article/details/42061017
马拉车算法，强烈推荐参考