最长回文字串、最长递增子序列、最长连续子数组、最大连续子数组的和

class Solution:
    def longestPalindrome(self, s: str) -> str:

        if not s:
            return ''

        dp = [[False for i in range(len(s))]for i in range(len(s))]

        for i in range(len(s)):
            dp[i][i] = True
        cur_start_index = 0
        max_length = 1
        for j in range(1,len(s)):
            for i in range(j):
                if s[i] == s[j]:
                    if j-i < 3:
                        dp[i][j] = True
                    else:
                        dp[i][j] = dp[i+1][j-1]
                if dp[i][j]:
                    cur_length = j-i+1
                    if cur_length > max_length:
                        max_length = cur_length
                        cur_start_index = i
        return s[cur_start_index:cur_start_index+max_length]

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:

        dp = [1 for i in range(len(nums))]

        for i in range(1,len(nums)):
            for j in range(i):
                if nums[j] < nums[i]:
                    dp[i] = max(dp[j] + 1,dp[i])
        return max(dp)

3、最长连续子数组(返回的是长度)

class Solition:
	def maxlength(self,arr):
		if len(arr) == 0:
			return 0
		if len(arr) == 1:
			return 1
		res = []
		length = 0
		for i in srr:
			while i in res:
				res.pop(0)
			res.append(i)
			length = max(length,len(res))
		return length

4、最大连续子数组的和

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
    	if not nums:
    		return 0
    	if len(nums) == 1:
    		return nums[0]
    	res = nums[0]
    	dp = 0
    	for i in range(len(nums)):
    		dp = max(nums[i]+dp,nums[i])
    		if res < dp:
    			res = dp
    	return res
dp方法：
class Solution:
    def maxSubArray(self, nums: List[int]) -> int:


        n = len(nums)
        dp = [0 for i in range(len(nums))]
        for i in range(n): # dp[i] = nums[i] + max(dp[i-1],0)(stored)
            dp[i] = nums[i] + max(dp[i - 1], 0)
        return max(dp)