【LeetCode练习题】5. 最长回文子串

写在前面

这个题目之前在高中的时候就曾经写过，现在到了研究生很多东西需要再重新捡起来的呢，在面试中也曾经两次遇到这样的题目，现在在今天2020年3月12日10:14:49统一整理一下，预计花费2个小时的时间。

题目描述

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

示例 1：

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

输入: “cbbd” 输出: “bb”

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-palindromic-substring
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

方法一：最长公共子串

最大的回文子串，可以替换成最长公共子串，两个字符串最长的公共的部分的，但是存在反向副本时，策略失效，需要补充条件进行判定，如果反向子串索引和原始索引相同则更新。

花了一个小时学习最长公共子串的算法，花了半个小时想出了序号的判别方法。时间复杂度O(n²) leetcode
不能AC最后一个样例超时。吃个饭继续搞~

    def longestPalindrome( s):
        string1=s
        string2=s[::-1]
        len1 = len(string1)
        len2 = len(string2)
        res = [[0 for i in range(len1+1)] for j in range(len2+1)]  
        #python 初始化二维数组 [len1+1],[len2+1]
        result =0
        index=0
        for i in range(1,len2+1):  #开始从1开始，到len2+1结束
            for j in range(1,len1+1):  #开始从1开始，到len2+1结束
                if string2[i-1] == string1[j-1]:
                    res[i][j] = res[i-1][j-1]+1
                    if (result<=res[i][j])& (len(string1)-i==j-res[i][j]):
                        index=j
                        result = res[i][j]        
        string=string1[index-result:index] 
   
        return string  # 输出
 print(longestPalindrome("adabxxcbada"))

方法二：暴力法

方法三：动态规划方法

动态规划的方法，关键在于寻找边界状态。这个也不能AC，会超时，关于数组边界的问题，让我体会了一把python的金穗。

def longestPalindrome(s):
        if(s == ""):  return s
        strlen = len(s)
        dp=[[False for i in range(len(s))] for j in range(len(s))]
        for i in range(len(s)): dp[i][i] = True
        for i in range(len(s)-1): dp[i][i+1] = (s[i] == s[i+1])
        left = 0
        right = 0
        maxnum = 1;
        for i in range(len(s)-2,-1,-1):  #下左标 ，从0 开始 一定要倒置，否则计算出来的有问题，从小到大推过来的。
            for j in range(1,len(s)):  #下右标
                # P(i,j)=(P(i+1,j−1) and Si==Sj)
                if(i != j ) & (j != i+ 1):
                    dp[i][j] = dp[i+1][j-1] & (s[i] == s[j]);
                if(dp[i][j]) & (maxnum < j - i + 1):
                    maxnum = j - i + 1;
                    left = i;
                    right = j;
                print(i,j,dp[i][j])
        return s[left:right+1];
print( longestPalindrome("ab"))

方法四：中心扩展法

解法五: Manacher’s Algorithm 马拉车算法

马拉车算法 Manacher‘s Algorithm 是用来查找一个字符串的最长回文子串的线性方法，由一个叫 Manacher 的人在 1975 年发明的，这个方法的最大贡献是在于将时间复杂度提升到了线性。

首先我们解决下奇数和偶数的问题，在每个字符间插入 “#”，并且为了使得扩展的过程中，到边界后自动结束，在两端分别插入 “^” 和 “$”，两个不可能在字符串中出现的字符，这样中心扩展的时候，判断两端字符是否相等的时候，如果到了边界就一定会不相等，从而出了循环。经过处理，字符串的长度永远都是奇数了。

首先我们用一个数组 P 保存从中心扩展的最大个数，而它刚好也是去掉 “#” 的原字符串的总长度。例如下图中下标是 6 的地方，可以看到 P[ 6 ] 等于 5，所以它是从左边扩展 5 个字符，相应的右边也是扩展 5 个字符，也就是 “#c#b#c#b#c#”。而去掉 # 恢复到原来的字符串，变成 “cbcbc”，它的长度刚好也就是 5。

求原字符串下标

用 P 的下标 i 减去 P [ i ]，再除以 2，就是原字符串的开头下标了。

例如我们找到 P[ i ] 的最大值为 5，也就是回文串的最大长度是 5，对应的下标是 6，所以原字符串的开头下标是（6 - 5 ）/ 2 = 0。所以我们只需要返回原字符串的第 0 到 第（5 - 1）位就可以了。

求每个 P [ i ]

接下来是算法的关键了，它充分利用了回文串的对称性。

我们用 C 表示回文串的中心，用 R 表示回文串的右边半径。所以 R = C + P[ i ]。C 和 R 所对应的回文串是当前循环中 R 最靠右的回文串。

让我们考虑求 P [ i ] 的时候，如下图。

用 i_mirror 表示当前需要求的第 i 个字符关于 C 对应的下标。

class Solution:
     def center_spread(self, s,center):
        size = len(s)
        i = center - 1
        j = center + 1
        step = 0
        while i >= 0 and j < size and s[i] == s[j]:
            i -= 1
            j += 1
            step += 1
        return step
     def longestPalindrome(self,s):
        # 特判 差一个空格，5个缩进的样子
        size = len(s)
        if size < 2:
            return s

        # 得到预处理字符串
        t = "#"
        for i in range(size):
            t += s[i]
            t += "#"
        # 新字符串的长度
        t_len = 2 * size + 1
        # 当前遍历的中心最大扩散步数，其值等于原始字符串的最长回文子串的长度
        max_len = 1
        # 原始字符串的最长回文子串的起始位置，与 max_len 必须同时更新
        start = 0

        for i in range(t_len):
            cur_len = self.center_spread(t, i)
            if cur_len > max_len:
                max_len = cur_len
                start = (i - max_len) // 2
        return s[start: start + max_len]
   

正常缩进是5个空格，定义类的时候self.就是方法的函数，定义的函数需要放置在使用的函数之前，这一点和matlab不一致，和Pascal比较一致。