代码随想录day45&day47

题目一

dp[i]表示i之前包括i的以nums[i]结尾的最长递增子序列的长度

对dp[i]，遍历j<i对所有nums[j],不断动态更新dp[i](dp[i]是不断更新的)

所有数组初始化为1

class Solution(object):
    def lengthOfLIS(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        dp = [1] * (len(nums))
        
        for i in range(1,len(dp)):
            for j in range(i):
                if nums[i] > nums[j]:
                    dp[i] = max(dp[j]+1,dp[i])

        return max(dp)

第二题

太简单了

class Solution(object):
    def findLengthOfLCIS(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        dp = [1] * (len(nums))
        
        for i in range(1,len(dp)):
                if nums[i] > nums[i-1]:
                    dp[i] = dp[i-1]+1

        return max(dp)

第三题

dp[i][j] ：以下标i - 1为结尾的A，和以下标j - 1为结尾的B，最长重复子数组长度为dp[i][j]

构建数组时i，j代表下标。长度均为len+1，最后一个代表整个数组遍历完。0下表代表前面为空字符串

根据dp[i][j]的定义，dp[i][j]的状态只能由dp[i - 1][j - 1]推导出来。

即当A[i - 1] 和B[j - 1]相等的时候，dp[i][j] = dp[i - 1][j - 1] + 1;

第一行和第一列都要初始化成0

class Solution(object):
    def findLength(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: int
        """
        dp = [[0]*(len(nums2)+1) for _ in range(len(nums1)+1)]
        res = 0
        for i in range(1,len(nums1)+1):
            for j in range(1,len(nums2)+1):
                if nums1[i-1] == nums2[j-1]:
                    dp[i][j]= dp[i-1][j-1]+1
                if dp[i][j] > res:
                    res = dp[i][j]

        
        return res

第四题

分为A[i-1]和B[j-1]相等和不相等两种情况，从三个方向推出

初始化条件同上

class Solution(object):
    def longestCommonSubsequence(self, text1, text2):
        """
        :type text1: str
        :type text2: str
        :rtype: int
        """
        dp = [[0]*(len(text2)+1) for _ in range(len(text1)+1)]
        res = 0
        for i in range(1,len(text1)+1):
            for j in range(1,len(text2)+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])

                if dp[i][j] > res:
                    res = dp[i][j]

第五题

实际上是找最长公共子序列，思路同上

class Solution(object):
    def maxUncrossedLines(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: int
        """
        dp = [[0]*(len(nums2)+1) for _ in range(len(nums1)+1)]
        res = 0
        for i in range(1,len(nums1)+1):
            for j in range(1,len(nums2)+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])
                if dp[i][j] > res:
                    res = dp[i][j]

        
        return res

第六题：

dp[i]：包括下标i（以nums[i]为结尾）的最大连续子序列和为dp[i]。

对于dp[i]，要么跟前面连上，要么以i为开始，取最大值即可

class Solution(object):
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        dp = [0] * len(nums)
        dp[0] = nums[0]
        res = dp[0]
  

        for i in range(1,len(nums)):
            dp[i] = max(dp[i-1]+nums[i],nums[i])
            if dp[i] > res:
                res = dp[i]
        return res

第七题

与第四题相同，不过在不相等时，只来自一个方向，因为s始终是t的子序列，t要减少，s不减

    def isSubsequence(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        dp = [[0]*(len(t)+1) for _ in range(len(s)+1)]
        res = 0
        for i in range(1,len(s)+1):
            for j in range(1,len(t)+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]

                if dp[i][j] > res:
                    res = dp[i][j]

        
        return res == len(s)