LeetCode#5.最长回文子串

一、题目描述

给定一个字符串s，找到s中最长的回文子串。你可以假设s的最大长度为1000。

示例1：

输入： “babad”
输出： “bab”
注意： “aba” 也是一个有效答案

示例2：

输入： “cbbd”
输出： “bb”

二、解法一：动态规划

思路：
对于一个字符串而言，如果它是回文串，并且长度大于2，那么将它首尾的两个字母去除之后，它仍然是个回文串。使用dp[i][j]来表示子串s[i…j]是否为回文串，得到状态转移方程：

$dp[i][j]=(s[i]==s[j]\&\&dp[i+1][j-1])$

边界条件考虑子串的长度为1或2。对于长度为1的子串，它必然是回文串；对于长度为2的子串，若它的两个字母相同，则为回文串。

代码：

class Solution {
public:
    string longestPalindrome(string s) {
        int n = s.size();
        vector<vector<int>> dp(n, vector<int>(n));
        string ans;
        for (int len = 0; len < n; ++len) {
            for (int i = 0; i + len < n; ++i) {
                int j = i + len;
                if (len == 0) {
                    dp[i][j] = 1;
                }
                else if (len == 1) {
                    dp[i][j] = (s[i] == s[j]);
                }
                else {
                    dp[i][j] = (s[i] == s[j] && dp[i + 1][j - 1]);
                }
                if (dp[i][j] && len + 1 > ans.size()) {
                    ans = s.substr(i, len + 1);
                }
            }
        }
        return ans;
    }
};

三、解法二：中心扩散

思路：
回文串一定是关于中心位置对称的。若回文串的长度为奇数，则中心位置是一个字符；若回文串的长度为偶数，则中心位置是位于中间的两个字符的“间隙”。


中心扩散法即遍历字符串的每一个字符，以当前字符或者当前字符后的间隙作为中间位置，往两侧扩散，寻找最长的回文子串。

代码：

class Solution {
public:
    int findPalindrome(const string& s, int left, int right)
    {
        int len = 0;
        while (left >= 0 && right < s.size() && s[left] == s[right])
        {
            left--;
            right++;
            len++;
        }
        return len;
    }

    string longestPalindrome(string s) {
        if (s.size() < 2)
            return s;

        int start = 0, end = 0;
        for (int i = 0; i < s.size() - 1; i++)
        {
            int oddLen = findPalindrome(s, i, i);
            int evenLen = findPalindrome(s, i, i + 1);
            if (oddLen * 2 - 1 > end - start)
            {
                start = i - oddLen + 1;
                end = i + oddLen - 1;
            }
            if (evenLen * 2 > end - start)
            {
                start = i - evenLen + 1;
                end = i + evenLen;
            }
        }
        return s.substr(start, end - start + 1);
    }
};