LeetCode 算法题库【5】——最长回文子串

最长回文子串

题目描述：

解题思路：

• 第一种：中心扩散法。这个思路是，我们可以通过从这个字符串子串的中心而不是起点来向两边同时扩散寻找回文子串。回文子串，顾名思义，就是这个字符串顺着读和反着读是一模一样的，也就是说这个字符串是类似对称的。
• 那么这里就有两种情况需要我们考虑：第一，如果这个回文子串的中心可以是一个字符，那么很容易知道这个字符串的字符数量为奇数，第二，如果这个回文子串的中心是空隙，意味着这个字串字符数量为偶数。那么这里我们可以设一个函数来计算和验证这两种情况是否符合回文子串的基本性质。通过while循环，如果满足条件则往两边扩散，看下一个字符是否符合回文条件。因为每次验证都会验证两次，也就是上面讲的两种情况，所以，每次验证时，都要记录这两种情况的回文子串和子串长度，后面要进行比较，也就是比较出哪一种回文子串最长，每次的最长的长度都会给maxi来保存，如果最后有字符串长度比这个maxi更大，那么这个回文子串就会给temp来进行保存，每次都是如此，最后当循环结束，maxi和temp保存的就是最大的回文字符串长度和最长回文子串。所以最后将temp赋给最后的结果result，返回就得到了最后的答案。
• 时间复杂度：O(N^2)

class Solution:
    def longestPalindrome(self, s: str) -> str:
        maxi = 1
        result = s[0] # 排除字符串s为空的情况。
        lens = len(s)
        if lens < 2:
            return s
        for i in range(lens):
            single, s_len = self.center_spread(s, lens, i, i)
            gap, g_len = self.center_spread(s, lens, i, i + 1)
            if s_len >= g_len:
                temp = single
            else:
                temp = gap
            # temp = single if s_len >= g_len else gap
            if len(temp) > maxi:
                maxi = len(temp)
                result = temp
        return result

    def center_spread(self, s, size, l, r):
        while l >= 0 and r < size and s[l] == s[r]:
            l -= 1
            r += 1
        return s[l + 1:r], r - l - 1

• 第二种：动态规划。这个方法虽然比前一种方法慢了许多，但是这个动态规划的思想是很重要的，需要好好掌握。首先，建立动态规划表格dp[i][j]来表示子串，每个位置都会代表着一个子串，我们先将其都赋予False，如果这个子串是回文子串，将会给这个位置改成True。然后用s[i, j]来表示这个回文子串，在这个dp二维表格里，因为子串中j > i恒成立，所以我们在这个二维表格只需要填写右半边即可。
• 然后我们开始验证，在这个方法里，和上面第一中方法不同的是，这个方法我们是从两边往中间缩小来寻找最长回文子串，当遇到s[i] == s[j]即子串的最左边和最右边元素相同时，则吧这两个元素去掉，验证中间这些元素是否仍然满足条件，也就是dp[i+1][i-1]，一直缩小范围直到位置差<= 2，也就是，这两个元素之间的字符只有1个或者0个即空隙，那么很明显，这两个情况都已经满足回文字串的条件了，所以给这个子串在二维表格中赋予True，如果验证过程中有一次失败，也就是不相同，那么可以直接断定这个子串不是回文子串，就给他赋予False。
• 下一步，我们就要保存这个子串的长度，只要是这个子串是回文子串，也就是dp[i][j] == True，那么我们需要保存下这个子串的长度，我定义了large来保存每次得到的回文子串长度，和maxi来保存这其中最大的长度，然后用start来保存这个最大的回文子串的起点，知道了起点，也知道了子串长度，通过python切片很容易就可以得到这个最长回文子串。通过多次的循环迭代，最后就能够得到最长的回文子串了。
• 时间复杂度：O(N^2)

class Solution:
    def longestPalindrome(self, s: str) -> str:
        if len(s) < 2:
            return s
        maxi = 1
        start = 0
        dp = [[False for _ in range(len(s))] for _ in range(len(s))]
        for j in range(1, len(s)):
            for i in range(0, j):
                if s[i] == s[j]:
                    if j - i <= 2:
                        dp[i][j] = True
                    else:
                        dp[i][j] = dp[i + 1][j - 1]
                else:
                    dp[i][j] = False
                # dp[i][j] = (s[i] == s[j]) and (j - i < 3 or dp[i + 1][j - 1])
                if dp[i][j]:
                    large = j - i + 1
                    if large > maxi:
                        maxi = large
                        start = i
        return s[start:start + maxi]

• 第三种：Manacher算法。也叫“马拉车”算法，这个方法解决这个问题很厉害，它可以说是专门用于解决“最长回文子串”问题的。他的思路就是我们在每两个字符中间插入一个#，然后我们将每个字符向左向右能够形成的最大回文子串的半径求出来，很容易可以推得，这其中最大的那个半径就是这个字符串中的回文子串的字符数目。主要的方法思路可以参考这个题解的第四个方法：Manacher算法。因为这个方法用的范围不是特别的广，所以了解就可以了。
• 时间复杂度：O(N)

class Solution:
    def longestPalindrome(self, s: str) -> str:
        size = len(s)
        if size < 2:
            return s
        t = "#"
        for i in range(size):
            t += s[i]
            t += "#"
        t_len = 2 * size + 1
        p = [0 for _ in range(t_len)]
        max_right = 0
        center = 0
        max_len = 1
        start = 1
        for i in range(t_len):
            if i < max_right:
                mirror = 2 * center - i
                p[i] = min(max_right - i, p[mirror])
            left = i - (1 + p[i])
            right = i + (1 + p[i])
            while left >= 0 and right < t_len and t[left] == t[right]:
                p[i] += 1
                left -= 1
                right += 1
            if i + p[i] > max_right:
                max_right = i + p[i]
                center = i
            if p[i] > max_len:
                max_len = p[i]
                start = (i - max_len) // 2
        return s[start: start + max_len]