Leetcode_Dynamic_Programming -- 5. Longest Palindromic Substring [medium]

Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.

给定一个字符串s，找到s的最长回文子串，假设s的最大长度是1000

Example 1:

Input: "babad"
Output: "bab"
Note: "aba" is also a valid answer.

Example 2:

Input: "cbbd"
Output: "bb"

动态规划，维护一个二维数组dp，dp[ j ][ i ]用来表示s[ j : i ]是否为回文串，是则dp[ j ][ i ]为1，否则为0。

初始化首先判定所有字符串均不为回文串，即dp初始化全为0；

可知当 i= j 即只有一个字母时，是回文串；

当 i = j+1 即为相邻字母时，如果s[ i ] = s[ j ]，那么dp[ j ][ i ]是回文串；

当 i - j >= 2 时 ，如果s[ i ] = s[ j ]，则判断dp[ j+1 ][ i-1 ] 是否为回文串，如果是，那么dp[ j ][ i ]为回文串。

其实上述分析分成了两种情况，即 i - j 与 2 的大小关系：

当 i - j < 2时，判断s[ i ] = s[ j ]是否为真，如果为真，那么dp[ j ][ i ]是回文串；

当 i - j >= 2时，除了判断s[ i ] = s[ j ]是否为真外，还需要判断dp[ j+1 ][ i-1 ]是否为真，如果两个都为真，那么dp[ j ][ i ]是回文串；

Solutions:

Python

(1)方法1和方法2是一样的，只不过状态方程的写法稍有不同
class Solution:
    def longestPalindrome(self, s: str) -> str:
        dp = [[0]*len(s) for i in range(len(s))]
        length = len(s)
        left = rigth = 0
        maxlength = 1

        for i in range(0,length):
            dp[i][i] = 1
            for j in range(0,i):
                if i -j <2:
                    dp[j][i] = int(s[i]==s[j])
                else:
                    dp[j][i] = int((s[i]==s[j])&(dp[j+1][i-1]))
                
                if dp[j][i] and (maxlength<i-j+1):#更新最大长度，记录最大回文串的起始与终止位置
                    left = j
                    rigth = i
                    maxlength = i-j+1
        return s[left:rigth+1]

(2)
class Solution:
    def longestPalindrome(self, s: str) -> str:
        dp = [[0]*len(s) for i in range(len(s))]
        length = len(s)
        left = rigth = 0
        maxlength = 1

        for i in range(0,length):
            dp[i][i] = 1
            for j in range(0,i):
                    dp[j][i] = (s[i]==s[j]) and (i-j<2 or dp[j+1][i-1]) #将方法1中的判断写入一行中
                    if dp[j][i] and (maxlength<i-j+1):
                        left = j
                        rigth = i
                        maxlength = i-j+1

        return s[left:rigth+1]