最长回文子串-动态规划5

Python-动态规划

考察对动态规划问题的理解和设计：
1.动态规划表格的构建；
2.状态转移方程的设计和实现；
3.动态规划边界条件的实现。

class Solution:
    def longestPalindrome(self, s):
        n = len(s)
        dp = [[False] * n for _ in range(n)] # 构建动态规划表格n x n
        ans = ""
        # 枚举子串的长度 l+1
        for l in range(n):
            # 枚举子串的起始位置 i，这样可以通过 j=i+l 得到子串的结束位置
            for i in range(n):
                j = i + l # 防止重复检索
                if j >= len(s): # 防止超出dp矩阵的范围
                    break
                if l == 0: 
                    dp[i][j] = True # 字符串只有一个字符，那一定是回文串
                elif l == 1: 
                    dp[i][j] = (s[i] == s[j]) # 字符串有两个字符，则坚持是否一致，若一致则为回文串
                else:
                    dp[i][j] = (dp[i + 1][j - 1] and s[i] == s[j]) # 状态转移方程，去掉首尾两个字符后为回文串，并且首尾两个字符一致，则一定为回文串
                if dp[i][j] and l + 1 > len(ans): # 若检索到的新回文串长度大于之前检索到的回文串长度，则更新ans为新的回文串
                    ans = s[i:j+1]
        return ans

复杂度分析：

• 时间复杂度：O(n²)，其中 n 是字符串的长度。动态规划的状态总数为 O(n²)，对于每个状态，我们需要转移的时间为 O(1)。
• 空间复杂度：O(n²)，即存储动态规划状态需要的空间。

ps.该方法实测有效，但是在leetcode官网测试会显示超时。

Python-中心扩展

未完待续

class Solution:
    def expandAroundCenter(self, s, left, right):
        while left >= 0 and right < len(s) and s[left] == s[right]:
            left -= 1
            right += 1
        return left + 1, right - 1

    def longestPalindrome(self, s: str) -> str:
        start, end = 0, 0
        for i in range(len(s)):
            left1, right1 = self.expandAroundCenter(s, i, i)
            left2, right2 = self.expandAroundCenter(s, i, i + 1)
            if right1 - left1 > end - start:
                start, end = left1, right1
            if right2 - left2 > end - start:
                start, end = left2, right2
        return s[start: end + 1]

复杂度分析：

• 时间复杂度：O(n²)，其中 n 是字符串的长度。长度为 11 和 22 的回文中心分别有 n 和 n-1
  个，每个回文中心最多会向外扩展 O(n) 次。
• 空间复杂度：O(1)。