动态规划14 | ● *1143.最长公共子序列 ● *1035.不相交的线 ● 53. 最大子序和 动态规划

*1143.最长公共子序列

视频讲解：https://www.bilibili.com/video/BV1ye4y1L7CQ
https://programmercarl.com/1143.%E6%9C%80%E9%95%BF%E5%85%AC%E5%85%B1%E5%AD%90%E5%BA%8F%E5%88%97.html

• 考点
  • 子序列问题
• 我的思路
  • 无思路
• 视频讲解关键点总结
  • 本题和上一篇文章的第718题——最长重复子数组的区别1在于，本题的dp[i][j]定义为序列1从头到下标i元素和序列2从头到下标j元素的最长递增子序列的长度（不强制要求包含第i和j个元素，如果使用强制要求包含第i和j个元素的思路也是可以写出来代码的，具体见下面的代码，但是时间复杂度会相对较高，无法通过；所以遇到这种问题，先想想不强制包含的时候能不能实现自己的逻辑，如果能实现是最好的，此时的递推公式一般比较简洁，时间复杂度低，如果实现不了想要的逻辑再考虑必须包含的写法）
  • 区别2在于递推公式，由于不强制要求包含第i和j个元素，所以本题的递推公式无论第i个元素和第j个元素是否相等都需要更新dp数组的值，当相等时，dp[i][j] = dp[i - 1][j - 1] + 1，不相等时，dp[i][j] = max(dp[i][j - 1], dp[i - 1][j])
• 我的思路的问题
  • 无思路
• 代码书写问题
  • 无
• 可执行代码

# dp[i][j]不强制要求包含第i和j个元素
class Solution:
    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        dp = [[0] * len(text2) for _ in range(len(text1))]
        for i in range(len(text1)):
            if text2[0] == text1[i]:
                for n in range(i, len(text1)):
                    dp[n][0] = 1
                break
        for j in range(len(text2)):
            if text2[j] == text1[0]:
                for n in range(j, len(text2)):
                    dp[0][n] = 1
                break
        for i in range(1, len(text1)):
            for j in range(1, len(text2)):
                if text2[j] == text1[i]:
                    dp[i][j] = dp[i - 1][j - 1] + 1
                else:
                    dp[i][j] = max(dp[i][j - 1], dp[i - 1][j])
        return dp[-1][-1]

# dp[i][j]强制要求包含第i和j个元素（时间复杂度较高，会超时）
class Solution:
    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        dp = [[0] * len(text2) for _ in range(len(text1))]
        max_value = 0
        for i in range(len(text1)):
            if text1[i] == text2[0]:
                dp[i][0] = 1
                max_value = 1
        for j in range(len(text2)):
            if text1[0] == text2[j]:
                dp[0][j] = 1
                max_value = 1
        for i in range(1, len(text1)):
            for j in range(1, len(text2)):
                if text1[i] == text2[j]:
                    for m in range(0, i):
                        for n in range(0, j):
                            dp[i][j] = max(dp[i][j], dp[m][n] + 1)
                if dp[i][j] > max_value:
                    max_value = dp[i][j]
        return max_value

*1035.不相交的线

视频讲解：https://www.bilibili.com/video/BV1h84y1x7MP
https://programmercarl.com/1035.%E4%B8%8D%E7%9B%B8%E4%BA%A4%E7%9A%84%E7%BA%BF.html

• 考点
  • 子序列问题
• 我的思路
  • 本题和上一题的解题思路完全一致
• 视频讲解关键点总结
  • 和上一题一致
• 我的思路的问题
  • 无
• 代码书写问题
  • 无
• 可执行代码

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

53. 最大子序和 动态规划

这道题我们用贪心做过，这次 再用dp来做一遍
视频讲解：https://www.bilibili.com/video/BV19V4y1F7b5
https://programmercarl.com/0053.%E6%9C%80%E5%A4%A7%E5%AD%90%E5%BA%8F%E5%92%8C%EF%BC%88%E5%8A%A8%E6%80%81%E8%A7%84%E5%88%92%EF%BC%89.html

• 考点
  • 子序列问题
• 我的思路
  • dp[i]的含义是，以元素i为结尾的连续子数组的最大和
  • 递推公式为，取仅以第i个元素为子数组的情况和在第i - 1个元素组成的连续子数组最大和上叠加当前元素的情况中的较大者
• 视频讲解关键点总结
  • 和我的思路一致
• 我的思路的问题
  • 无
• 代码书写问题
  • 无
• 可执行代码

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