Leetcode刷题第十四天-动态规划

674:最长连续递增序列

链接：674. 最长连续递增序列 - 力扣（LeetCode）

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

718：最长重复子序列

链接：718. 最长重复子数组 - 力扣（LeetCode）

class Solution:
    def findLength(self, nums1: List[int], nums2: List[int]) -> int:
        #dp[i][j]数组nums1中第i-1号元素之前与数组nums2中第j-1号元素之前的最长重复子数组
        #dp[i][j]=dp[i-1][j-1]+1
        m,n=len(nums1),len(nums2)
        re=0
        dp=[[0 for i in range(n+1)] for j in range(m+1)]
        for i in range(1,m+1):
            for j in range(1,n+1):
                if(nums1[i-1]==nums2[j-1]): dp[i][j]=dp[i-1][j-1]+1
                re=max(re,dp[i][j])
        return re

1143:最长公共子序列

链接：1143. 最长公共子序列 - 力扣（LeetCode）

class Solution:
    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        m,n,=len(text1),len(text2)
        dp=[[0 for i in range(n+1)] for j in range(m+1)]
        re=0
        for i in range(1,m+1):
            for j in range(1,n+1):
                if(text1[i-1]==text2[j-1]):  dp[i][j]=dp[i-1][j-1]+1
                else:   dp[i][j]=max(dp[i-1][j],dp[i][j-1])
            re=max(re,max(dp[i]))
        print(dp)
        return re

1035:不相交的线

链接：1035. 不相交的线 - 力扣（LeetCode）

和1143一样

class Solution:
    def maxUncrossedLines(self, nums1: List[int], nums2: List[int]) -> int:
        #dp[]
        m,n=len(nums1),len(nums2)
        dp=[[0 for i in range(n+1)] for j in range(m+1)]
        re=0
        for i in range(1,m+1):
            for j in range(1,n+1):
                if(nums1[i-1]==nums2[j-1]): dp[i][j]=dp[i-1][j-1]+1
                else:   dp[i][j]=max(dp[i-1][j],dp[i][j-1])
            re=max(re,max(dp[i]))
        return re

53:最大字数和

链接：53. 最大子数组和 - 力扣（LeetCode）

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        n=len(nums)
        dp=[0]*n
        dp[0]=nums[0]
        for i in range(1,n):
            dp[i]=max(nums[i],dp[i-1]+nums[i])
        #print(dp)
        return max(dp)

392:判断子序列

链接：392. 判断子序列 - 力扣（LeetCode）

class Solution:
    def isSubsequence(self, s: str, t: str) -> bool:
        n,m=len(s),len(t)
        re=0
        dp=[[0 for i in range(m+1)] for j in range(n+1)]
        for i in range(1,n+1):
            for j in range(1,m+1):
                if(s[i-1]==t[j-1]):    dp[i][j]=dp[i-1][j-1]+1
                else:   dp[i][j]=dp[i][j-1]
            re=max(re,max(dp[i]))
        print(dp)
        if(re==n):  return True
        return False

115:不同的子序列

链接：115. 不同的子序列 - 力扣（LeetCode）

class Solution:
    def numDistinct(self, s: str, t: str) -> int:
        #获取指定子序列的方法
        m,n=len(s),len(t)
        dp=[[0 for i in range(n+1)]for j in range(m+1)]
        for i in range(m+1):    dp[i][0]=1
        for i in range(1,m+1):
            for j in range(1,n+1):
                if(s[i-1]==t[j-1]): dp[i][j]=dp[i-1][j-1]+dp[i-1][j]
                else:   dp[i][j]=dp[i-1][j]
        return dp[-1][-1]

583:两个字符串的删除操作

链接：583. 两个字符串的删除操作 - 力扣（LeetCode）

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        m,n=len(word1),len(word2)
        dp=[[0 for i in range(m+1)]for j in range(n+1)]
        for i in range(n+1):    dp[i][0]=i
        for i in range(m+1):    dp[0][i]=i
        for i in range(1,n+1):
            for j in range(1,m+1):
                if(word1[j-1]==word2[i-1]): dp[i][j]=dp[i-1][j-1]
                else:   dp[i][j]=min(dp[i-1][j]+1,dp[i][j-1]+1,dp[i-1][j-1]+2)
        return dp[-1][-1]

72：编辑距离

链接：72. 编辑距离 - 力扣（LeetCode）

修改单词有三种方式：增、删、换

word1删i-1元素dp[i-1][j]，word2删j-1元素dp[i][j-1]，word1和word2都删dp[i-1][j-1]+2

替换dp[i-1][j-1]+1，替换后word1[i-1]=word2[j-1]

添加=删除的逆向操作，word1增加一个单吃=word2减去一个单词

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        len1,len2=len(word1),len(word2)
        dp=[[0 for i in range(len2+1)]for j in range(len1+1)]
        for i in range(len1+1): dp[i][0]=i
        for i in range(len2+1): dp[0][i]=i
        for i in range(1,len1+1):
            for j in range(1,len2+1):
                if(word1[i-1]==word2[j-1]): dp[i][j]=dp[i-1][j-1]
                else:   dp[i][j]=min(dp[i-1][j]+1,dp[i][j-1]+1,dp[i-1][j-1]+1)
                #word1删i-1元素dp[i-1][j],word2删j-1元素dp[i][j-1],word1和word2都删dp[i-1][j-1]+2
                #替换dp[i-1][j-1]+1
                #添加=删除的逆向操作
        return dp[-1][-1]

647：回文子串

链接：647. 回文子串 - 力扣（LeetCode）

class Solution:
    def countSubstrings(self, s: str) -> int:
        #dp[i][j]  i到j范围内串是否是回文
        #s[i]=s[j] j-i<=1,aa，s[i:j]是回文，j-i>1,dp[i+1][j-1]是回文，s[i:j]是回文
        n,re=len(s),0
        dp=[[False for i in range(len(s))]for j in range(len(s))]
        for i in range(len(s)-1,-1,-1):
            for j in range(i,len(s)):
                if(s[i]==s[j]):
                    if(j-i<=1):  
                        dp[i][j]=True
                        re+=1
                    elif(dp[i+1][j-1]):
                        dp[i][j]=True
                        re+=1
        return re
                

516:最长回文子序列

链接：516. 最长回文子序列 - 力扣（LeetCode）

class Solution:
    def longestPalindromeSubseq(self, s: str) -> int:
        #dp初始化，i=j,dp[i][j]=1
        #遍历顺序：i倒序，j正序
        n=len(s)
        dp=[[0 for i in range(n)]for j in range(n)]
        for i in range(n):    dp[i][i]=1
        for i in range(n-1,-1,-1):
            for j in range(i+1,n):
                if(s[i]==s[j]): dp[i][j]=dp[i+1][j-1]+2
                else:   dp[i][j]=max(dp[i+1][j],dp[i][j-1])
        return dp[0][-1]