leetcode第五题最长回文串

class Solution:
    def longestPalindrome(self, s: str) -> str:
        length=len(s)
        max_len=0
        final_str=''
        for i in range(length):
            for j in range(i+1,length+1):
                first_str=s[i:j]
                second_str=first_str[::-1]
                if first_str==second_str:
                    if max_len<len(first_str):  
                        final_str=first_str
                        max_len=len(first_str)
        return final_str

暴力解法

class Solution:
    def longestPalindrome(self, s: str) -> str:
        length=len(s)
        begin=0
        max_len=0
        if length<2:
            return s
        
        # 第一次遇到这种写法 dp的初始
        dp=[[False]*length for _ in range(length)]

        # 单个字母的初始为True
        for i in range(length):
            dp[i][i]=True

        # 遍历 重点
        # l的range写2，length+1没通过 写1
        for l in range(1,length+1):
            for i in range(length):
                j=l+i-1
                # 越界
                if j>=length:
                    break
                
                if s[i]!=s[j]:
                    dp[i][j]=False
                else:
                    if l<=3:
                        dp[i][j]=True
                    else:
                        dp[i][j]=dp[i+1][j-1]
                
                if dp[i][j] and l>max_len:
                    max_len=l
                    begin=i
        # python的字符串切片不包括最后那一个啊
        return s[begin:begin+max_len]

动态规划

class Solution:
    def longestPalindrome(self, s: str) -> str:
        # 想想要怎么写
        def expand(s,i,j):
            n=len(s)
            while i>=0 and j<n and s[i]==s[j]:
                i -=1
                j +=1
            return i+1,j-1
        
        start=end=0
        length=len(s)
        for i in range(length):
            # 两种可能 a aa
            start1,end1=expand(s,i,i)
            start2,end2=expand(s,i,i+1)
            # 思考一下
            if end1-start1>end-start:
                start=start1
                end=end1
            if end2-start2>end-start:
                start=start2
                end=end2
        return s[start:end+1]
    

中心扩展