LeetCode(C++)刷题计划：5-最长回文子串

5-最长回文子串

@Author：CSU张扬
@Email：csuzhangyang@gmail.com or csuzhangyang@qq.com

1. 题目

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

示例 1：
输入: "babad"
输出: "bab"
注意: "aba" 也是一个有效答案。

示例 2：
输入: "cbbd"
输出: "bb"

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-palindromic-substring/

2. 解法

参考：windliang

2.1 解法一：最长共同子串(动态规划法)

2.1.1 为什么用可以最长共同子串？

1. 假设s2是s1的逆序字符串。
2. 若s1中有回文子串，则s1和s2中一定有相同的该子串。
   例如：s1 = "afbcbfae", 则s2 = "eafbcbfa",那么fbcbf就是它俩的共同最长子串，也是s1的最长回文子串。
3. 不过需要注意一些特例：s1 = "abc123cba", 则s2 = "abc321cba";我们发现它俩有两个共同子串abc和bca，但是这两个都不是回文子串。
4. 对于3中的情况，我们需要加一步判断来解决该问题。即s1中abc和s2中abc他们的下标是否对应。对于s2中子串abc来讲，其中a在s1逆置之前的下标应该是8(即:s1.size() - 1)。通用的说法就是，当s2[j] == s[i]时，设s2中的该字符c在s2中的下标为j，它在逆置之前，在s1中的下标为jBefore，那么jBefore = s1.size() - 1 - j，此时s1中下标为i，d[i][j]是该回文串的长度，那么就必须满足i = jBefore + d[i][j] - 1。那么我们可以推断出，当s1[i] == s[j]时，只要满足该条件，那么就是回文子串。

2.1.2 动态规划法

1. 我们设置一个二维n*n数组d表示两个字符串每个字符相等的关系。（字符串长度为n）
2. 若s1[i] == s[j]，则d[i][j] = d[i-1][j-1] + 1。当i=0或者j=0时，上述公式会越界。所以我们直接令d[i][j] = 1。
3. 例如s1 = "afbcbfae"，那么d为

   s1\s2	e	a	f	b	c	b	f	a
   a	0	1	0	0	0	0	0	1
   f	0	0	2	0	0	0	1	0
   b	0	0	0	3	0	1	0	0
   c	0	0	0	0	4	0	0	0
   b	0	0	0	1	0	5	0	0
   f	0	0	1	0	0	0	6	0
   a	0	1	0	0	0	0	0	7
   e	1	0	0	0	0	0	0	0

   我们只需记录下d中最大数对应的下标即可。
   我们观察到d[2][3]=3(行为i，列为j)，此时j = 3, jBefroe = 8-1-3 = 4; i = 2而jBefore + d[i][j] - 1 = 4+3-1 = 6,所以此时不是回文子串。
   再看d[6][7]=7，此时j = 7, jBefroe = 8-1-7 = 0; i = 6而jBefore + d[i][j] - 1 = 0+7-1 = 6,所以此时是回文子串。
4. 对于s1 = "abc123cba"来说，d为

   s1\s2	a	b	c	3	2	1	c	b	a
   a	1	0	0	0	0	0	0	0	1
   b	0	2	0	0	0	0	0	1	0
   c	0	0	3	0	0	0	1	0	0
   1	0	0	0	0	0	1	0	0	0
   2	0	0	0	0	1	0	0	0	0
   3	0	0	0	1	0	0	0	0	0
   c	0	0	1	0	0	0	1	0	0
   b	0	1	0	0	0	0	0	2	0
   a	1	0	0	0	0	0	0	0	3

   我们观察到d[2][2]=3(行为i，列为j)，此时j = 2, jBefroe = 9-1-2 = 6; i=2而jBefore + d[i][j] - 1 = 6+3-1 = 7,所以此时不是回文子串。
   再看d[8][8]=3，此时j = 8, jBefroe = 9-1-8 = 0; i = 8而jBefore + d[i][j] - 1 = 0+3-1 = 2,所以此时也不是回文子串。

执行用时 :320 ms, 在所有 cpp 提交中击败了22.88%的用户
内存消耗 :13.3 MB, 在所有 cpp 提交中击败了47.92%的用户

// 时间复杂度O(n^2),空间复杂度O(n^2)
class Solution {
public:
    string longestPalindrome(string s) {
        int n = s.size();
        if (n == 0)
            return "";
        string s1 = s;
        reverse(s1.begin(), s1.end());
        int d[n][n];
        int maxLen = 0;
        int maxEnd = 0;
        for (auto i = 0; i < n; ++ i) {
            for (auto j = 0; j < n; ++ j) {
                if (s[i] == s1[j]) {
                    if (i > 0 && j > 0)
                        d[i][j] = d[i-1][j-1] + 1;
                    else
                        d[i][j] = 1;
                }
                else {
                    d[i][j] = 0;
                }
                if (d[i][j] > maxLen) {
                    int jBeforeReverse = n - 1 - j;
                    if (jBeforeReverse + d[i][j] - 1 == i) {
                        maxLen = d[i][j];
                        maxEnd = i;
                    }
                }
            }
        }
        return s.substr(maxEnd - maxLen + 1, maxLen);
    }
};

2.2解法二：最长共同子串(改进)

在解法一中我们使用了二维数组，实际上使用一维数组也可以解决。
解法一中，当i=0时，我们计算出j=1…n的值，i=1时，我们又根据前一列计算出这一列的j=1…n的值。实际上，我们计算某一列的值时，只需要使用它的左上角的元素（d[i][j] = d[i-1][j-1] + 1），即前一列的信息。

我们规定若s1[i] == s[j]，则d[j] = d[j-1] + 1。当j=0时，上述公式会越界。所以我们直接令d[j] = 1。

但是我们必须要注意到如下的问题：
假设i=0时，我们已经求出一组d的值，当i=1时，如果我们j从0——n来循环，那么
比如求出d[1] = d[0] + 1（此时d[0]还是上一次的信息）。我们再求d[2] = d[1] + 1，但这时d[1]的值已经被修改了，不是i=0时的值了。
所以我们的j必须从n——0来循环。

执行用时 :268 ms, 在所有 cpp 提交中击败了28.68%的用户
内存消耗 :8.7 MB, 在所有 cpp 提交中击败了96.28%的用户

class Solution {
public:
    string longestPalindrome(string s) {
        int n = s.size();
        if (n == 0)
            return "";
        string s1 = s;
        reverse(s1.begin(), s1.end());
        int d[n];
        int maxLen = 0;
        int maxEnd = 0;
        for (auto i = 0; i < n; ++ i) {
            for (auto j = n - 1; j >= 0; -- j) {
                if (s[i] == s1[j]) {
                    if (i > 0 && j > 0)
                        d[j] = d[j-1] + 1;
                    else
                        d[j] = 1;
                }
                else {
                    d[j] = 0;
                }
                if (d[j] > maxLen) {
                    int jBeforeReverse = n - 1 - j;
                    if (jBeforeReverse + d[j] - 1 == i) {
                        maxLen = d[j];
                        maxEnd = i;
                    }
                }
            }
        }
        return s.substr(maxEnd - maxLen + 1, maxLen);
    }
};

2.3 解法三：中心拓展法

核心思想就是指定一个中心元素，分别比较两侧的元素是否相等。
当然我们会遇到奇数个或偶数个的回文子串。
对于奇数个的，我们指定一个中心元素；对于偶数个的，我们指定两个中心元素；然后向两侧拓展比较。

执行用时 :20 ms, 在所有 cpp 提交中击败了90.24%的用户
内存消耗 :8.7 MB, 在所有 cpp 提交中击败了96.28%的用户

// 时间复杂度O(n^2),空间复杂度O(1)
class Solution {
public:
    string longestPalindrome(string s) {
        int n = s.size();
        if (n == 0)
            return "";
        int start = 0, maxLen = 0;
        for (auto i = 0; i < n; ++ i) {
            int len1 = expandFromCenter(s, i, i);
            int len2 = expandFromCenter(s, i, i + 1);
            int len = max(len1, len2);
            if (len > maxLen) {
                maxLen = len;
                start = i - (len - 1)/2;
            }
        }
        return s.substr(start, maxLen);
    }
    int expandFromCenter(string &s, int left, int right) {
        while (left >= 0 && right < s.size() && s[left] == s[right]) {
            left --;
            right ++;
        }
        // 每次到循环最后，left多减了1，right多加了1
        return (right - left - 1);
    }
};

2.4 解法四：Manacher’s Algorithm 马拉车算法

好复杂，日后再更。