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

最新推荐文章于 2026-08-19 23:01:13 发布
原创 最新推荐文章于 2026-08-19 23:01:13 发布 · 1k 阅读 · 16 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测

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

一、最长公共子序列

相关题目：Leetcode1143
文档讲解：Leetcode1143
视频讲解：Leetcode1143

1. Leetcode1143.最长公共子序列

给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。
一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

  • 例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。

两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。
提示：

  • 1 <= text1.length, text2.length <= 1000
  • text1 和 text2 仅由小写英文字符组成。
  • 思路：
    • 动规五部曲：
      • 确定 dp 数组以及下标的含义:dp[i][j] 表示长度为 [0, i - 1] 的字符串 text1 与长度为 [0, j - 1] 的字符串 text2 的最长公共子序列为 dp[i][j]（简化 dp 数组第一行和第一列的初始化逻辑）。
      • 确定递推公式：主要就是两大情况：
        • 如果 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])。
      • dp 数组如何初始化：text1[0, i-1] 和空串的最长公共子序列自然是 0，所以 dp[i][0] = 0；同理 dp[0][j] 也是 0。其他下标都是随着递推公式逐步覆盖，初始为多少都可以，统一初始为 0。
      • 确定遍历顺序：从递推公式可以看出，有三个方向可以推出 dp[i][j]，如图：
        请添加图片描述
        所以要从前向后，从上到下来遍历这个矩阵。
      • 举例推导 dp 数组：以输入：text1 = “abcde”, text2 = “ace” 为例，dp 状态如图：
        请添加图片描述
  • 二维 dp
class Solution:
    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        # 创建一个二维数组 dp，用于存储最长公共子序列的长度
        dp = [[0] * (len(text2) + 1) for _ in range(len(text1) + 1)]
        
        # 遍历 text1 和 text2，填充 dp 数组
        for i in range(1, len(text1) + 1):
            for j in range(1, len(text2) + 1):
                if text1[i - 1] == text2[j - 1]:
                    # 如果 text1[i-1] 和 text2[j-1] 相等，则当前位置的最长公共子序列长度为左上角位置的值加一
                    dp[i][j] = dp[i - 1][j - 1] + 1
                else:
                    # 如果 text1[i-1] 和 text2[j-1] 不相等，则当前位置的最长公共子序列长度为上方或左方的较大值
                    dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
        
        # 返回最长公共子序列的长度
        return dp[len(text1)][len(text2)]
  • 一维 dp
class Solution:
    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        m, n = len(text1), len(text2)
        dp = [0] * (n + 1)  # 初始化一维DP数组
        
        for i in range(1, m + 1):
            prev = 0  # 保存上一个位置的最长公共子序列长度
            for j in range(1, n + 1):
                curr = dp[j]  # 保存当前位置的最长公共子序列长度
                if text1[i - 1] == text2[j - 1]:
                    # 如果当前字符相等，则最长公共子序列长度加一
                    dp[j] = prev + 1
                else:
                    # 如果当前字符不相等，则选择保留前一个位置的最长公共子序列长度中的较大值
                    dp[j] = max(dp[j], dp[j - 1])
                prev = curr  # 更新上一个位置的最长公共子序列长度
        
        return dp[n]  # 返回最后一个位置的最长公共子序列长度作为结果

二、不相交的线

相关题目：Leetcode1035
文档讲解：Leetcode1035
视频讲解：Leetcode1035

1. Leetcode1035.不相交的线

在两条独立的水平线上按给定的顺序写下 nums1 和 nums2 中的整数。
现在，可以绘制一些连接两个数字 nums1[i] 和 nums2[j] 的直线，这些直线需要同时满足：

  • nums1[i] == nums2[j]
  • 且绘制的直线不与任何其他连线（非水平线）相交。

请注意，连线即使在端点也不能相交：每个数字只能属于一条连线。以这种方法绘制线条，并返回可以绘制的最大连线数。
提示：

  • 1 <= nums1.length, nums2.length <= 500
  • 1 <= nums1[i], nums2[j] <= 2000

  • 思路：

    • 题目要求直线不能相交，这就是说明在字符串 nums1中找到一个与字符串 nums2 相同的子序列，且这个子序列不能改变相对顺序，只要相对顺序不改变，连接相同数字的直线就不会相交。以 nums1 = [1,4,2], nums2 = [1,2,4] 为例，相交情况如图：
      请添加图片描述
    • 本题说是求绘制的最大连线数，其实就是求两个字符串的最长公共子序列的长度！ 方法与 Leetcode1143.最长公共子序列 一模一样。

  • 二维 dp

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

三、最大子序和

相关题目：Leetcode53
文档讲解：Leetcode53
视频讲解：Leetcode53

1. Leetcode53. 最大子序和

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。子数组是数组中的一个连续部分。
提示：

  • 1 <= nums.length <= 105
  • -104 <= nums[i] <= 104
  • 思路：

    • 动规五部曲：

      • 确定dp数组以及下标的含义：dp[i] 表示包括下标 i（以 nums[i] 为结尾）的最大连续子序列和。
      • 确定递推公式 ：dp[i] 有两个方向可以推出来：
        • dp[i - 1] + nums[i]，即：nums[i] 加入当前连续子序列和；
        • nums[i]，即：从头开始计算当前连续子序列和；

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

      • dp 数组如何初始化：从递推公式可以看出来 dp[i] 依赖于 dp[i - 1] 的状态，dp[0] 就是递推公式的基础。根据 dp[i] 的定义，dp[0] 应为 nums[0] 即 dp[0] = nums[0]。
      • 确定遍历顺序：递推公式中 dp[i] 依赖于 dp[i - 1] 的状态，需要从前向后遍历。
      • 举例推导 dp 数组：以 nums = [-2,1,-3,4,-1,2,1,-5,4] 为例，对应的 dp 状态如下：
        请添加图片描述
  • 动规
class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        dp = [0] * len(nums)
        dp[0] = nums[0]
        result = dp[0]
        for i in range(1, len(nums)):
            dp[i] = max(dp[i-1] + nums[i], nums[i]) #状态转移公式
            result = max(result, dp[i]) #result 保存dp[i]的最大值
        return result

四、判断子序列

相关题目：Leetcode392
文档讲解：Leetcode392
视频讲解：Leetcode392

1. Leetcode392.判断子序列

给定字符串 s 和 t ，判断 s 是否为 t 的子序列。
字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，"ace"是"abcde"的一个子序列，而"aec"不是）。
进阶：
如果有大量输入的 S，称作 S1, S2, … , Sk 其中 k >= 10亿，你需要依次检查它们是否为 T 的子序列。在这种情况下，你会怎样改变代码？
提示：

  • 0 <= s.length <= 100
  • 0 <= t.length <= 10^4
  • 两个字符串都只由小写字符组成。

  • 思路：

    • 动规五部曲：

      • 确定 dp 数组以及下标的含义：dp[i][j] 表示以下标 i-1 为结尾的字符串 s，和以下标 j-1 为结尾的字符串 t，相同子序列的长度为 dp[i][j]。注意这里是判断 s 是否为 t 的子序列。即 t 的长度是大于等于 s 的。
      • 确定递推公式：在确定递推公式的时候，首先要考虑如下两种操作，整理如下：
        • 当 s[i - 1] == t[j - 1]，t 中找到了一个字符在 s 中也出现了，那么 dp[i][j] = dp[i - 1][j - 1] + 1；
        • 当 s[i - 1] != t[j - 1])，相当于 t 要删除元素，继续匹配，t 如果把当前元素 t[j - 1] 删除，那么 dp[i][j] 的数值就依赖于 s[i - 1] 与 t[j - 2] 的比较结果，即：dp[i][j] = dp[i][j - 1]。

      本题和 Leetcode1143.最长公共子序列 的递推公式基本一样，区别就是本题如果删元素一定是字符串 t，而 Leetcode1143.最长公共子序列 是两个字符串都可以删元素。

      • dp 数组如何初始化：从递推公式可以看出 dp[i][j] 依赖于 dp[i - 1][j - 1] 和 dp[i][j - 1]，所以 dp[0][0] 和 dp[i][0] 需要初始化。dp[i][0] 表示以下标 i-1 为结尾的字符串，与空字符串的相同子序列长度，所以初始化为 0；dp[0][j] 同理。
      • 确定遍历顺序：因为 dp[i][j] 依赖于 dp[i - 1][j - 1] 和 dp[i][j - 1]，所以遍历顺序应该是从上到下，从左到右，如图所示：
        请添加图片描述
      • 举例推导 dp 数组：以 s = “abc”, t = “ahbgdc” 为例，dp 状态转移图如下：
        请添加图片描述

  • 动规

class Solution:
    def isSubsequence(self, s: str, t: str) -> bool:
        dp = [[0] * (len(t)+1) for _ in range(len(s)+1)]
        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[-1][-1] == len(s):
            return True
        return False
标签
#leetcode #python #算法 #数据结构
代码随想录算法训练营Day38 | 1143.最长公共子序列、1035.不相交得线、53.最大子序和、392.判断子序列
2401_86818319的博客
12-05 720
特性最长公共子序列 (LCS)判断子序列目标找到两个字符串共有的、最长的子序列。判断s是否是t的子序列。dp[i][j]定义s前i个与t前j个的LCS长度。s前i个与t前j个的LCS长度。字符不匹配时s[i-1]和t[j-1]都不能用，可以丢弃任意一个，取最优解。t[j-1]没用，只能丢弃t[j-1]，继续寻找s[i-1]。else分支公式核心思想双向选择，寻找最大值。单向搜索，s是目标，t是文本。
代码随想录算法训练营 | 专题九 动态规划
m0_56867252的博客
01-25 1410
1. dp[i]代表到达当前位置的cost，即 i-1 + cost[i-1] 或 i-2 + cost[i-2]2. dp[i]表示当前位置总消耗（算上当前位置cost，顶层由倒数第一二层决定）第n级楼梯可以有第n-1级跨一步或第n-2级跨两步到达，情况数遵循加法原理。（dp[0]=1无意义，只是为了让dp[2]=2）简单题，如果要省空间可以只操作及更新三个值。因此相加即为到达n级楼梯的爬楼梯方法；数列同样为斐波那契数列。
LeetCode 102. 二叉树的层序遍历｜Python 解法详解
a1250467048的博客
08-14 159
这道题的关键是：广度优先搜索天然按层访问。理解这一点后，再结合边界条件检查，代码就能保持清晰且稳定。
力扣（合并区间）
最新发布
weixin_52811458的博客
08-19 287
给定一组可能重叠或相邻的整数区间，合并所有重叠或端点相接的区间，返回不重叠的最小区间列表。例如输入 [[1,3],[2,6],[8,10],[15,18]]，输出 [[1,6],[8,10],[15,18]]。核心是先按左端点升序排序，再单次线性扫描完成合并，避免暴力两两比较。
leetcode 56合并区间
qq_63176310的博客
08-15 220
这道题你可以把它压缩成一个非常好记的思路：先排序，再逐个比较；能合并就扩右边界，不能合并就加入答案。具体来说，先用： 把所有区间按照左端点从小到大排序。排序之后，我们只需要拿“当前区间”和 里最后一个已经合并好的区间比较。如果： 说明前一个区间的右端点比当前区间左端点还小，二者没有重叠： 所以直接： 如果不满足： 那就说明： 两个区间重叠，例如： 此时左端点不用动，只需要把右端点扩大： 所以整道题可以记成： 这道题容易忘的函数/语法 含义：对整个 排序。对于：
LeetCode //MySQL - 1204. Last Person to Fit in the Bus
Made in Code
08-19 346
This SQL query solves the problem of finding the last person who can board a bus without exceeding the 1000 kg weight limit. The solution involves: Calculating a running total of weights ordered by boarding turn using a window function Filtering to only in
LeetCode 1. 两数之和 | 从暴力枚举到哈希表最优解 + 空间换时间思想全复盘
yc2284238579的博客
08-19 218
文章摘要 题目要求在数组中找到两数之和等于目标值的下标。核心思路是优化查找效率： 暴力法：双重循环枚举所有数对，时间复杂度O(n²)，效率低但易实现。 哈希表优化：利用哈希表O(1)查找特性，遍历时存储已访问元素，每次计算差值并查询，时间复杂度降至O(n)。关键细节是先查后存，避免自匹配。 代码实现：哈希表法通过一次遍历完成，空间换时间，边界处理需注意空数组和不足两元素的情况。 常见错误：内层循环起始点、哈希表键值设计、立即返回结果等易错点需警惕。 面试要点：优先选择哈希表解法，解释与暴力法的差异，强调时间
【leetcode】153. 寻找旋转排序数组中的最小值js
2402_83244812的博客
08-19 131
本文介绍了在旋转排序数组中寻找最小值的二分查找算法。通过比较中间元素与数组末尾元素，可以确定最小值所在区间：若中间值大于末尾值，则最小值在右侧；否则在左侧或当前位置。文章提供了两种实现方式，第一种通过样例总结返回nums[l]，第二种采用更标准的二分写法，确保循环结束时left==right。两种方法时间复杂度均为O(logn)，适用于解决LeetCode相关题目。关键点在于利用旋转数组的特性缩小搜索范围。
LeetCode //C - 1203. Sort Items by Groups Respecting Dependencies
Made in Code
08-18 364
This problem involves sorting items with group constraints and dependency relations. The key steps are: Assign unique groups to items with no group (-1) Build dependency graphs for both items and groups Perform topological sorting on both graphs If both so
10.LeetCode算法习题讲解--滑动窗口--最大连续为一的个数
Jammy_1的博客
08-19 190
利用滑动窗口解决最大连续1的个数
LeetCode hot100——最大子数组和
weixin_42927227的博客
08-18 203
给你一个整数数组nums，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。是数组中的一个连续部分。6连续子数组 [4,-1,2,1] 的和最大，为 6。nums = [1]123如果你已经实现复杂度为O(n)的解法，尝试使用更为精妙的求解。
LeetCode //C - 1200. Minimum Absolute Difference
Made in Code
08-15 383
Abstract: The problem asks to find all pairs of elements with the smallest absolute difference in an array containing distinct integers and return these pairs in ascending order. The solution involves first sorting the array, then comparing the differences
LeetCode 3597.分割字符串
tus00000的博客
08-17 219
时间复杂度：O(n) 或 O(n∣Σ∣)，其中 n 是 s 的长度，∣Σ∣=26 是字符集合的大小。空间复杂度：O(n) 或 O(n∣Σ∣)。只要当前段是唯一的，就将其加入段列表，标记为已经出现过，并从下一个下标开始构建新的段。因此，最终输出为 [“a”, “b”, “bc”, “c”, “cc”, “d”]。输出： [“a”,“b”,“bc”,“c”,“cc”,“d”]因此，最终输出为 [“a”, “aa”]。输入： s = “abbccccd”输入： s = “aaaa”输出： [“a”,“aa”]
LeetCode //C - 1202. Smallest String With Swaps
Made in Code
08-17 344
Summary: This problem involves finding the lexicographically smallest string achievable by swapping characters at given indices any number of times. The key idea is to use Union-Find to group all swappable indices into connected components. Characters with
【leetcode】33.搜索旋转排序数组js
2402_83244812的博客
08-19 289
本文介绍了在旋转排序数组中查找目标值的二分搜索算法。通过分析四种可能情况（mid值和目标值分别位于左右两段的不同组合），将问题转化为常规二分搜索或特殊指针移动。当mid值和目标值位于同一段时按常规二分处理；位于不同段时根据相对位置调整搜索方向。算法时间复杂度为O(log n)，适用于部分有序数组的快速查找。文章附有JavaScript实现代码和情况分类表格，清晰展示了处理逻辑。
LeetCode 34：在排序数组中查找元素的第一个和最后一个位置（二分查找） —— 题解
2601_96587588的博客
08-19 522
二分查找经典题目——在排序数组中查找元素的第一个和最后一个位置
LeetCode 35. 搜索插入位置（二分查找详解 + Java Python 实现）
2603_95532426的博客
08-14 366
这道题要求在有序数组中查找目标值的插入位置。关键点在于使用二分查找实现O(log n)的时间复杂度。二分查找过程中，当中间值等于目标值时直接返回索引；若中间值小于目标值则搜索右半部分，否则搜索左半部分。循环结束后，左指针left指向的位置即为目标值应插入的位置。文章详细解释了二分查找的原理和边界条件，并提供了Java和Python的实现代码。通过分析循环终止时left和right指针的关系，证明了left指针的正确性。总结指出，二分查找是基础算法，掌握后能解决许多类似问题。
leetcode 240搜索二维矩阵
qq_63176310的博客
08-16 233
所以每比较一次，都能排除一整行或一整列。，说明当前这一列下面的数只会更大，所以。表示只要还没有走出矩阵，就继续寻找。更小，所以当前这一行不可能找到。：最后一个元素的后一个位置。因为这一行左边的数字只会比。表示直接读取矩阵中的一行，：表示这个位置上的值。：第一个元素的位置；
leetcode 238除了自身以外数组的乘积
qq_63176310的博客
08-15 229
该代码实现了一个O(n)时间复杂度的算法，用于计算数组中每个元素除自身外其他元素的乘积。其核心思路是：先从左到右遍历数组，计算每个位置左侧所有元素的乘积存入L数组；再从右到左遍历，计算右侧所有元素的乘积存入R数组；最后将L和R数组对应位置相乘得到结果。例如对于输入[1,2,3,4]，先得到L=[1,1,2,6]和R=[24,12,4,1]，最终结果为[24,12,8,6]。该方法避免了除法运算，通过两次遍历实现了高效计算。
LeetCode hot 100 —41. 缺失的第一个正数
Canmido的博客
08-18 221
普通数组-5-困难
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值