[LeetCode]5.最长回文子串

题目

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

示例 1：

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

示例 2：

输入: "cbbd"
输出: "bb"

解题思路

解法一：暴力法（超时）

根据回文子串的定义，枚举所有长度大于等于2的子串，依次判断它们是否是回文；
在具体实现时，可以只针对大于“当前得到的最长回文子串长度”的子串进行“回文验证”；
在记录最长回文子串的时候，可以只记录“当前子串的起始位置”和“子串长度”，不必做截取。
步骤：
1)对长度小于2的字符串进行特判；
2)枚举所有长度大于等于2的字符串，并判断其是否是回文，这里可以单独写一个判断是否是回文的函数
3)
复杂度分析：
时间复杂度：O(N^3)，这里 N 是字符串的长度，枚举字符串的左边界、右边界，然后继续验证子串是否是回文子串，这三种操作都与 N 相关；
空间复杂度：O(1)，只使用到常数个临时变量，与字符串长度无关。

解法二：动态规划

动态规划”最关键的步骤是想清楚“状态如何转移”，事实上，“回文”是天然具有“状态转移”性质的：一个回文去掉两头以后，剩下的部分依然是回文（这里暂不讨论边界）。
因此，从回文串的定义展开讨论：
1、如果一个字符串的头尾两个字符都不相等，那么这个字符串一定不是回文串；
2、如果一个字符串的头尾两个字符相等，才有必要继续判断下去。
（1）如果里面的子串是回文，整体就是回文串；
（2）如果里面的子串不是回文串，整体就不是回文串。
即在头尾字符相等的情况下，里面子串的回文性质据定了整个子串的回文性质，这就是状态转移。因此可以把“状态”定义为原字符串的一个子串是否为回文子串。
第一步，定义状态
dp[i][j] 表示子串 s[i, j] 是否为回文串；
第二步，状态转移方程
dp[i][j] = {(s[i] == s[j]) and dp[i+1][j-1]}
分析此方程，
1）“动态规划”事实上是在填一张二维表格，i 和 j 的关系是 i <= j ，因此，只需要填这张表的上半部分；
2）看到 dp[i + 1][j - 1] 就得考虑边界情况。dp[i+1][j-1] 的边界情况是 [i+1, j-1] 不构成区间，即长度小于2，也即 j - 1- ( i + 1 ) + 1 < 2，即 j - i < 3，也就是说子串 s[i, j] 长度等于2或3。这时候，其实只需要判断一下头尾两个字符是否相等就可以直接下结论了。
如果子串 s[i + 1, j - 1] 只有 1 个字符，即去掉两头，剩下中间部分只有 1 个字符，当然是回文；
如果子串 s[i + 1, j - 1] 为空串，那么子串 s[i, j] 一定是回文子串。
因此，在 s[i] == s[j] 成立和 j - i < 3 的前提下，直接可以下结论，dp[i][j] = true，否则才执行状态转移。
第三步，初始化
初始化的时候，单个字符一定是回文串，因此把对角线先初始化为 1，即 dp[i][i] = 1 。事实上，初始化的部分都可以省去。因为只有一个字符的时候一定是回文，dp[i][i] 根本不会被其它状态值所参考。
第四步，输出
只要一得到 dp[i][j] = true，就记录子串的长度和起始位置，没有必要截取，因为截取字符串也要消耗性能，记录此时的回文子串的“起始位置”和“回文长度”即可。

下面是编码的时候要注意的事项：总是先得到小子串的回文判定，然后大子串才能参考小子串的判断结果。具体思路是：
1、在子串右边界 j 逐渐扩大的过程中，枚举左边界可能出现的位置；
2、左边界枚举的时候可以从小到大，也可以从大到小。

for j in range(1,size):
    for i in range(0,j):

for j in range(1,size):
    for i in range(j-1,-1,-1):

或者是：
1、在子串左边界 i 逐渐减小的过程中，枚举右边界可能出现的位置；
2、右边界枚举的时候可以从小到大，也可以从大到小。

for i in range(size-2,-1,-1):
    for j in range(i+1,size):

for i in range(size-2,-1,-1):
    for j in range(size-1,i,-1):

步骤：
1)对长度小于2的字符串进行特判；
2)初始化一个二维dp数组，初值全部为 False；
3)设置两个迭代变量，即最大回文子串起始点和其长度，可分别设置为 0 和 1；
4)根据转移方程，进行动态规划；
5)最后返回迭代变量所记录的最大回文子串即可。

复杂度分析：
时间复杂度：O(n^2) 。
空间复杂度：O(n^2)，该方法使用 O(n^2)的空间来存储表。

代码

解法一：暴力法（超时）

class Solution:
    def isPalindrome(self, s, left, right):
        while left<right:
            if s[left] !=s[right]:
                return False
            left += 1
            right -= 1
        return True
            
    def longestPalindrome(self, s: str) -> str:
        size = len(s)
        if size<2:
            return s
        max_len = 0
        res = s[0]
        for i in range(0, size-1):
            for j in range(i+1, size):
                if (j-i+1)>max_len and self.isPalindrome(s, i, j):
                    max_len = j-i+1
                    res = s[i:j+1]
        return res

解法二：动态规划

class Solution:         
    def longestPalindrome(self, s: str) -> str:
        size = len(s)
        if size<2:
            return s
        dp = [[False for _ in range(size)] for _ in range(size)]
        max_len = 1
        start = 0
        # 这部分可有可无
        # for i in range(size):
        #     dp[i][i] = True
        for i in range(size-2,-1,-1):
            for j in range(i+1, size):
                if s[i]==s[j]:
                    if j-i<3:
                        dp[i][j]=True
                    else:
                        dp[i][j]=dp[i+1][j-1]
                else:
                    dp[i][j]=False
                if dp[i][j]:
                    cur_len = j-i+1
                    if cur_len>max_len:
                        max_len = cur_len
                        start = i
        return s[start:start+max_len]