每日一道Leetcode - 5. 最长回文子串 【动态规划】

class Solution:
    def longestPalindrome(self, s: str) -> str:
        """
        # 对于长度大于2的字符串，我们认为去掉首尾字符相等且去掉之后里面的仍然是回文子串
        # 对于长度等于1的字符串，默认为回文字符串
        # 长度为2的字符串，只要两个元素相等则为回文字符串
        
        # 官方题解 超时
        n = len(s)
        dp = [[False for _ in range(n)] for _ in range(n)]
        # 记录返回的回文字符串结果
        ans = ""
        #dp[i][j] 表示子串 s[i..j] 是否为回文子串，这里子串 s[i..j] 定义为左闭右闭区间，可以取到 s[i] 和 s[j]。
        
        for l in range(n):
            for i in range(n):
                # 枚举子串，子串长度用l控制，从i到i+l的
                # 对于长度为1[即用0表示]的"babad"
                # 此时的字符串为b、a、b、a、d
                # 若长度为2[即用1表示]的“babad”
                # 此时的字符串将为ba\ab\ba\ad
                j = i + l
                if j>=len(s):
                    break
                if l == 0:
                    # 长度为1时候全是回文字符串
                    dp[i][j] = True
                elif l == 1:
                    # 长度为2的时候判断两个字符是否相等
                    dp[i][j] = (s[i] == s[j])
                else:
                    # 长度大于2的时候缩小区间判断
                    dp[i][j] = (dp[i+1][j-1] and s[i] == s[j])
                if dp[i][j] and l+1>len(ans):
                    ans = s[i:j+1]
        return ans
        """

        n = len(s)
        # 如果长度小于2，则为回文
        if n<2:
            return s
        # 定义dp二维数组
        dp = [[False for _ in range(n)] for _ in range(n)]

        max_len = 1
        start = 0

        # 自己到自己，相当于只有一个字符，为回文串，设置为True
        for i in range(n):
            dp[i][i] = True
        # 枚举区间终点
        for j in range(1,n):
            # 枚举区间的起点
            for i in range(0,j):
                # i开始，j结尾的子串
                if s[i] == s[j]:
                    if j-i < 3:
                        # 判断当前缩进的区间是否<2，小于2一定为回文
                        # j-1-(i+1)+1 <2
                        # j-1-i-1+1-2<0
                        # j-i<3 
                        dp[i][j] = True
                    else:
                        # 否则就是缩进区间判断
                        dp[i][j] = dp[i+1][j-1]
                else:
                    # 不等于一定是False,不能满足缩进区间的要求
                    dp[i][j] = False
                # 如果此时的dp[i][j]为True,判断当前长度是否大于最大长度，如果大于，则更新子串开始点以及最大长度max_len
                if dp[i][j]:
                    cur_len = j-i+1
                    if cur_len > max_len:
                        max_len = cur_len
                        start = i
        # 返回start开始，长度为max_len的子串
        return s[start:start + max_len]