Leetcode习题两数相加，最长回文子串等

两数相加

方法一：

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        n = len(nums)
        for i in range(n):
            for j in range(i + 1, n):
                if nums[i] + nums[j] == target:
                    return [i, j]
    return []

方法二：

 class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        hashtable = dict()
        for i, num in enumerate(nums):
            if target - num in hashtable:
                return [hashtable[target - num], i]
            hashtable[nums[i]] = i
        return []

最长回文子串

中心扩散法

class Solution:
    def expandAroundCenter(self, s,size,left,right) :
         """
        left = right 的时候，此时回文中心是一个字符，回文串的长度是奇数
        right = left + 1 的时候，此时回文中心是一个空隙，回文串的长度是偶数
        """

        while left>=0 and right<len(s) and s[left]==s[right]:
           left-=1
           right+=1
        return s[left+1:right],right-left-1# 注意此处s[l+1 : r]是输出s[l+1], s[l+2], ... s[r-1]

    def longestPalindrome(self, s:str) ->str:
        size=len(s)
        max_len=1
        res=s[0]
        for i in range (size):
            odd,odd_length=self.expandAroundCenter(s,size,i,i)#奇数？
            even,even_length=self.expandAroundCenter(s,size,i,i+1)#偶数？
             # 调用函数，分别以s[i](子串长度为奇数)、s[i]和s[i+1]的中间(长度为偶数)为中心进行扩散，寻找最长回文子串
            max_sub=odd if odd_length>even_length else even
            if len(max_sub)>max_len:
                max_len=len(max_sub)
                res=max_sub
        return res

动态规划法

class Solution:
    def longestPalindrome(self, s: str) -> str:
        size = len(s)
        if size < 2:
            return s
            
    	dp = [[False for _ in range(size)] for _ in range(size)]

    	max_len = 1
    	start = 0

    	for i in range(size):
        	dp[i][i] = True

    	for j in range(1, size):
        	for i in range(0, j):
            	if s[i] == s[j]:
                	if j - i < 3:
                    	dp[i][j] = True
                	else:
                    	dp[i][j] = dp[i + 1][j - 1]
            	else:
                	dp[i][j] = False

            	if dp[i][j]:
                	cur_len = j - i + 1
                	if cur_len > max_len:
                    	max_len = cur_len
                    	start = i
    	return s[start:start + max_len]