leetcode动态规划 72，198，213，516，674

以下全部用python3编写
5:

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]

作者：liweiwei1419
链接：https://leetcode-cn.com/problems/longest-palindromic-substring/solution/zhong-xin-kuo-san-dong-tai-gui-hua-by-liweiwei1419/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

72：

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        n1 = len(word1)
        n2 = len(word2)
        dp = [[0] * (n2 + 1) for _ in range(n1 + 1)]
        # 第一行
        for j in range(1, n2 + 1):
            dp[0][j] = dp[0][j-1] + 1
        # 第一列
        for i in range(1, n1 + 1):
            dp[i][0] = dp[i-1][0] + 1
        for i in range(1, n1 + 1):
            for j in range(1, n2 + 1):
                if word1[i-1] == word2[j-1]:
                    dp[i][j] = dp[i-1][j-1]
                else:
                    dp[i][j] = min(dp[i][j-1], dp[i-1][j], dp[i-1][j-1] ) + 1
        #print(dp)      
        return dp[-1][-1]

198：

class Solution:
    def rob(self, nums: List[int]) -> int:
        #特殊情况处理
        if not nums:
            return 0
        if len(nums)==1:
            return nums[0]
        n=len(nums)
		#初始化状态转移数组
        dp=[0]*n
		#第一个边界值处理
        dp[0]=nums[0]
		#第二个边界值处理
        dp[1]=max(nums[0],nums[1])
		#遍历数组，写入状态方程
        for i in range(2,n):
            dp[i]=max(dp[i-2]+nums[i],dp[i-1])
        return  dp[-1]

213：

class Solution:
    def rob(self, nums: List[int]) -> int:
        if not nums:
            return 0
        if len(nums)<=2:
            return max(nums)
        def xiaotou(nums):
            if len(nums) <= 2:
                return max(nums)
            dp=[0]*len(nums)
            dp[0]=nums[0]
            dp[1]=max(nums[0],nums[1])
            for i in range(2,len(nums)):
                dp[i]=max(dp[i-2]+nums[i],dp[i-1])
            return dp[-1]
        return max(xiaotou(nums[1:len(nums)]),xiaotou(nums[:-1]))

516：

class Solution:
    def longestPalindromeSubseq(self, s: str) -> int:
        import functools
        
        @functools.lru_cache(None)
        def dfs(i, j):
            if s[i:j + 1] == s[i:j + 1][::-1]: return j - i + 1
            if i > j: return 0
            res = 0
            if s[i] == s[j]:
                res = max(res, 2 + dfs(i + 1, j - 1))
            return max(res, dfs(i + 1, j), dfs(i, j - 1))
        
        return dfs(0, len(s) - 1)

作者：powcai
链接：https://leetcode-cn.com/problems/longest-palindromic-subsequence/solution/dong-tai-gui-hua-zi-di-xiang-shang-he-zi-ding-xi-2/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

674：

class Solution:
    def findLengthOfLCIS(self, nums: List[int]) -> int:
        #判断边界条件
        if not nums:
            return 0
        #初始化dp数组
        dp=[1]*len(nums)
        #遍历数组
        for i in range (1,len(nums)):
            if nums[i]>nums[i-1]:
                dp[i]=dp[i-1]+1
            else:
                dp[i]=1
        return max(dp)