day38-数据结构力扣

1143.最长公共子序列

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

思路

1. dp 数组定义

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

2. 递推公式

若当前字符相等：text1[i-1] == text2[j-1]，dp[i][j]=dp[i−1][j−1]+1
若不相等：取左边或上边最大值，dp[i][j]=max(dp[i−1][j], dp[i][j−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(左, 上)

提交

python 复制代码

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]：dp[i][j]=dp[i−1][j−1]+1
不相等：dp[i][j]=max(dp[i−1][j], dp[i][j−1])

3. 初始化

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

4. 遍历顺序

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

5. 结果

dp[m][n]

`提交`

python 复制代码

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. 递推公式

要么把当前数加入前面的子数组
要么从当前数重新开始

dp[i]=max(nums[i], dp[i−1]+nums[i])

3. 初始化

dp[0] = nums[0]

4. 遍历

从左到右一遍遍历

5. 结果

dp 数组里的最大值

提交

python 复制代码

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.dp[i][j]

dp[i][j]: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)]

提交

python 复制代码

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]