LeetCode(27), 5. 最长回文子串

题目link

解法1

暴力循环，
对每一个子字符串，判断是否是回文。
记录回文子字符串的最大长度

时间复杂度 O(N^3)
空间复杂度 O(N)

"""
1. 暴力解法
    对每一个子字符串，判断是否是回文。
    记录回文子字符串的最大长度
    
    时间复杂度 O(N^3)
    空间复杂度 O(N)
"""

class Solution1:
    def longestPalindrome(self, s: str) -> str:
        size = len(s)
        if (size < 2):
            return s

        max_len = 1
        res = s[0]

        # loop for every substring
        for i in range(size-1):
            for j in range(i+1, size):
                # if the substring is palindrome and its length larger than current max length,
                # update max length
                if (j-i+1 > max_len) and (self.isPalindrome(s, i, j)):
                    max_len = j-i+1
                    res = s[i: j+1]
        return res

    # check whether substring is palindrome
    def isPalindrome(self, s: str, left: int, right: int):
        while left < right:
            if (s[left] != s[right]):
                return False
            else:
                left += 1
                right -= 1
        return True


solution = Solution1()
s = "aba"
print(solution.longestPalindrome(s))
print(solution.isPalindrome("aba", 0, 2))

解法2

动态规划
dp[i][j] 表示字串s[i, j] 是否为回文。
状态转移方程为
dp[i][j] = (s[i] == s[j]) && (dp[i+1][j-1])
对于二维表格中每一个元素，根据其左下角的值，以及判断s[i] == s[j] 的值来判断是否为真。

class Solution:
    def longestPalindrome(self, s: str) -> str:
        size = len(s)
        if size < 2:
            return s
        
        dp = [[False for i in range(size)] for j in range(size)]
        max_len = 1
        start = 0

        for r in range(size):
            for l in range(r+1):
                if (l == r):
                    dp[l][r] = True
                elif r - l == 1:
                    dp[l][r] = (s[l] == s[r])
                else: 
                    dp[l][r] = (dp[l+1][r-1]) and (s[l] == s[r])
                    # if palindrome length > max_len, update max_len
                if dp[l][r] and r-l+1 > max_len: 
                    max_len = r-l+1
                    start = l 

        return s[start: start+max_len]