代码随想录算法训练营第四十四天|1143.最长公共子序列、1035.不相交的线、53. 最大子序和、392.判断子序列

今日题目

1143.最长公共子序列

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

思考：对于两个字符串，计算最长公共子序列的长度，首先定义dp数组dp[i][j]，长度为[0, i - 1]的字符串text1与长度为[0, j - 1]的字符串text2的最长公共子序列为dp[i][j]。

如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;

如果text1[i - 1] 与 text2[j - 1]不相同，那就看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。即：dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])。

text1[0, i-1]和空串的最长公共子序列自然是0，所以dp[i][0] = 0;同理dp[0][j]也是0。

其他下标都是随着递推公式逐步覆盖，初始为多少都可以，那么就统一初始为0。

代码：

class Solution:
    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        m = len(text1)
        n = len(text2)
        dp = [[0] * (n+1) for _ in range(m+1)]
        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])
        return dp[m][n]

1035.不相交的线

题目：1035. 不相交的线 - 力扣（LeetCode）

思考：本题看起来有些不同于以往的数组题目，需要考虑两个数组之间相同元素连线，并且不能由线相交。实际上，能满足题目要求的连线，连起来的数字为两个数组的最长公共子序列，因此，本题在本质上是求两个数组的最长公共子序列，解法与上一题相同。

代码：

class Solution:
    def maxUncrossedLines(self, nums1: List[int], nums2: List[int]) -> int:
        m = len(nums1)
        n = len(nums2)
        dp = [[0] * (n+1) for _  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
                else:
                    dp[i][j] = max(dp[i-1][j], dp[i][j-1])
        return dp[m][n]

53. 最大子序和

题目：53. 最大子数组和 - 力扣（LeetCode）

思考：本题考虑采用动态规划算法求解，定义dp数组为dp[i]：包括下标i（以nums[i]为结尾）的最大连续子序列和为dp[i]。

dp[i]只有两个方向可以推出来：

• dp[i - 1] + nums[i]，即：nums[i]加入当前连续子序列和
• nums[i]，即：从头开始计算当前连续子序列和

一定是取最大的，所以dp[i] = max(dp[i - 1] + nums[i], nums[i])。

从递推公式可以看出来dp[i]是依赖于dp[i - 1]的状态，dp[0]就是递推公式的基础。

根据dp[i]的定义，很明显dp[0]应为nums[0]即dp[0] = nums[0]。

代码：

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

392.判断子序列

题目：392. 判断子序列 - 力扣（LeetCode）

思考：本题要判断字符串s是否为字符串t的子序列，可以转化为s为s和t的最长公共子序列，求解思路与计算最长公共子序列基本一致，最后结果需要转换为true或false。

代码：

class Solution:
    def isSubsequence(self, s: str, t: str) -> bool:
        m = len(s)
        n = len(t)
        dp = [[0] * (n+1) for _ in range(m+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] + 1
                else:
                    dp[i][j] = dp[i][j-1]
        if dp[-1][-1] == m:
            return True
        else:
            return False