day38-数据结构力扣

1143.最长公共子序列

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

思路

1. dp 数组定义

dp[i][j]：text1 前 i 个字符，text2 前 j 个字符的最长公共子序列长度。

2. 递推公式

• 若当前字符相等：text1[i-1] == text2[j-1]，dpij=dpi−1j−1+1

• 若不相等：取左边或上边最大值，dpij=max(dpi−1j, dpij−1)

3. 初始化

第一行、第一列全为 0：空字符串和任何字符串的公共子序列长度都是 0。

4. 遍历顺序

i 从 1 到 len (text1)，j 从 1 到 len (text2)从上到下、从左到右遍历。

5. 结果

dp[len(text1)][len(text2)]

区别

• 最长公共子数组（连续）

  • 相等：dp[i][j] = dp[i-1][j-1]+1

  • 不等：直接置 0

• 最长公共子序列（不连续）

  • 相等：dp[i][j] = dp[i-1][j-1]+1

  • 不等：dp[i][j] = max(左, 上)

提交

class Solution:
    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        m = len(text1)
        n = len(text2)
        
        # dp[i][j]：text1前i个、text2前j个的最长公共子序列长度
        dp = [[0] * (n + 1) for _ in range(m + 1)]
        
        for i in range(1, m + 1):
            for j in range(1, n + 1):
                # 当前字符相等，斜上角+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）

思路

这道题完全等价于求两个数组的最长公共子序列长度

连线不相交 ⇔ 相对顺序不变 ⇔ 就是 LCS 问题

1. dp 定义

dp[i][j]：nums1 前 i 个数、nums2 前 j 个数，能画的最大不相交连线数

2. 递推公式

• 若 nums1[i-1] == nums2[j-1]：dpij=dpi−1j−1+1

• 不相等：dpij=max(dpi−1j, dpij−1)

3. 初始化

第 0 行、第 0 列全为 0，空数组无连线。

4. 遍历顺序

i 依次遍历 nums1，j 依次遍历 nums2

5. 结果

dp[m][n]

提交

class Solution:
    def maxUncrossedLines(self, nums1: List[int], nums2: List[int]) -> int:
        m, n = len(nums1), len(nums2)
        # dp[i][j]：前i、前j个数的最大不相交连线数
        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）

思路

1. dp 数组含义

dp[i]：以 nums i 结尾的最大连续子数组和

2. 递推公式

• 要么把当前数加入前面的子数组

• 要么从当前数重新开始

dpi=max(numsi, dpi−1+numsi)

3. 初始化

dp[0] = nums[0]

4. 遍历

从左到右一遍遍历

5. 结果

dp 数组里的最大值

提交

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        n = len(nums)
        # dp[i] 表示以第i个元素结尾的最大子数组和
        dp = [0] * n
        dp[0] = nums[0]
        max_sum = dp[0]  # 记录全局最大值
        
        for i in range(1, n):
            # 核心：要么接在前面，要么自己重新开始
            dp[i] = max(nums[i], dp[i-1] + nums[i])
            # 更新最大值
            max_sum = max(max_sum, dp[i])
        
        return max_sum

392.判断子序列

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

思路

1.dpij

dpij:s前i个、t前j个，s 是否是 t 的子序列

2.递推

s[i-1] == t[j-1]：dp[i][j] = dp[i-1][j-1]

不等：dp[i][j] = dp[i][j-1]

3.初始化

dp[0][j] = True（空串是任何串的子序列）

4.遍历

i 遍历 s，j 遍历 t

5.结果

dp[len(s)][len(t)]

提交

class Solution:
    def isSubsequence(self, s: str, t: str) -> bool:
        m, n = len(s), len(t)
        # dp[i][j]：s前i个 是否是 t前j个 的子序列
        dp = [[False]*(n+1) for _ in range(m+1)]
        
        # 空s一定是子序列
        for j in range(n+1):
            dp[0][j] = True
        
        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]
                else:
                    dp[i][j] = dp[i][j-1]
        return dp[m][n]