1143. 最长公共子序列
给定两个字符串
text1和text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回0。一个字符串的 子序列是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。
- 例如，
"ace"是"abcde"的子序列，但"aec"不是"abcde"的子序列。两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。
cpp
class Solution {
public:
int longestCommonSubsequence(string text1, string text2) {
int n = text1.size(), m = text2.size();
// dp[i][j] 定义：text1 的前 i-1 个字符，和 text2 的前 j-1 个字符，它们的最长公共子序列长度
// 整体偏移一位，让 dp[0][j] 和 dp[i][0] 作为全 0 的安全垫
vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));
for(int i = 1; i <= n; i++){
for(int j = 1; j <= m; j++){
// 情况 1：字符匹配上了
if(text1[i-1] == text2[j-1]){
// 继承对角线（左上角）的长度 + 1
dp[i][j] = dp[i-1][j-1] + 1;
}
// 情况 2：字符没匹配上
else {
// 谁能让子序列更长，就继承谁（抛弃 text1[i-1] 或 抛弃 text2[j-1]）
dp[i][j] = max(dp[i-1][j], dp[i][j-1]);
}
}
}
return dp[n][m];
}
};总结
1. 为什么这里必须有 else？
- 718题（要求连续/子数组）：如果不相等，连续性当场断裂，长度直接归零，所以不需要
else，靠初始化的 0 兜底。 - 本题（不要求连续/子序列）：如果不相等，比如
abc和aec，当比到b和e时虽然不相等，但前面的a依然有效！所以不能归零，必须去左边dp[i][j-1]或 上边dp[i-1][j]找一个最大的历史遗产继承下来。
2. 二维网格的移动逻辑
在脑海中把 dp 想象成一个网格，你拿着两个指针 i 和 j 在右下角往左上角推：
- 遇到相同字符 → 往左上角走一步（
+1）。 - 遇到不同字符 → 往左边看一眼，往上面看一眼，取两者最大值。
- 边界：第一行和第一列永远是 0（因为其中一个字符串是空的，不可能有公共部分）。
1035. 不相交的线
在两条独立的水平线上按给定的顺序写下
nums1和nums2中的整数。现在，可以绘制一些连接两个数字
nums1[i]和nums2[j]的直线，这些直线需要同时满足：
nums1[i] == nums2[j]- 且绘制的直线不与任何其他连线（非水平线）相交。
请注意，连线即使在端点也不能相交：每个数字只能属于一条连线。
以这种方法绘制线条，并返回可以绘制的最大连线数。
cpp
class Solution {
public:
int maxUncrossedLines(vector<int>& nums1, vector<int>& nums2) {
int n = nums1.size(), m = nums2.size();
// 经典的双串安全垫初始化
vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));
for(int i = 1; i <= n; i++){
for(int j = 1; j <= m; j++){
// 你会发现，这里的逻辑和 1143.最长公共子序列 完全一模一样
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[n][m];
}
};总结
1. 为什么"不相交的线" = "最长公共子序列"？
在脑海中画一下连线的过程：
- 如果
nums1中的数字 A 和 nums2 中的数字 B 相等，你在它们之间画一条线。 - 题目要求线不能交叉。线一旦交叉，说明在
nums1中靠后的元素，连上了nums2中靠前的元素。 - 这就意味着，能够合法画出来的线，它们在
nums1中的相对顺序，和在nums2中的相对顺序，必须是完全一致的。 - "相对顺序一致且元素相同"，这不就是子序列的定义吗？
- 要求画最多的线，就是求最长的子序列。
53. 最大子数组和
给你一个整数数组
nums，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。子数组 是数组中的一个连续部分。
cpp
class Solution {
public:
int maxSubArray(vector<int>& nums) {
int n = nums.size();
// dp[i] 定义：以 nums[i] 结尾的连续子数组的最大和
// 不需要初始化为 INT_MIN。因为 dp[i] 必然包含 nums[i]，所以初始值天然就是 nums[i]
vector<int> dp(n);
dp[0] = nums[0];
int res = nums[0];
for(int i = 1; i < n; i++){
// 【核心逻辑】：要么重新开局（只要自己），要么接在前面的和后面
// 无论选哪个，dp[i] 至少也是 nums[i]，绝对不可能是 INT_MIN
dp[i] = max(nums[i], dp[i-1] + nums[i]);
res = max(res, dp[i]);
}
return res;
}
};总结
1. 状态转移方程的本质是什么？
dp[i] = max(nums[i], dp[i-1] + nums[i])
- 如果
dp[i-1]（前面的累加和）是正数 ，那加上我肯定更大，我就接上 （dp[i-1] + nums[i]）。 - 如果
dp[i-1]是负数 ，那加上你只会拖累我，我就断开 ，从我自己重新开始算（nums[i]）。
核心抓手：一旦连续和变成负数，立刻抛弃，重新开局。
2. 为什么不需要 INT_MIN 防御？
dp[i] 的定义是"以 nums[i]结尾"。既然 nums[i] 必须在里面，那就算前面全都是极小的负数，dp[i] 的底线也是 nums[i] 本身。它永远有明确的物理意义，不可能变成无效值。
392. 判断子序列
给定字符串 s 和 t ，判断 s 是否为 t 的子序列。
字符串的一个子序列是原始字符串删除一些（也可以不删除）字符而不改变剩余字符相对位置形成的新字符串。（例如，
"ace"是"abcde"的一个子序列，而"aec"不是）。
cpp
class Solution {
public:
bool isSubsequence(string s, string t) {
int n = s.size(), m = t.size();
// dp[i][j] 定义：以 s[i-1] 结尾的子串，和以 t[j-1] 结尾的子串，它们的公共子序列长度
vector<vector<int>> dp(n + 1, vector<int>(m + 1, 0));
for(int i = 1; i <= n; i++){
for(int j = 1; j <= m; j++){
if(s[i-1] == t[j-1]){
// 匹配上了，长度 +1
dp[i][j] = dp[i-1][j-1] + 1;
}
else {
// 【核心考点】：匹配不上时，为什么只看左边 dp[i][j-1]？
dp[i][j] = dp[i][j-1];
}
}
}
// 如果最长公共子序列的长度等于 s 的长度，说明 s 整体都是 t 的子序列
return dp[n][m] == n;
}
};总结
1. 为什么 else 里去掉了 max，只剩下 dp[i][j-1]？
这是由题目的单向包含关系决定的。
- 1143题（求LCS） ：
s和t是平起平坐的。如果不相等，我不知道是丢掉s的字符好，还是丢掉t的字符好，所以得看上边和左边，取个max(dp[i-1][j], dp[i][j-1])。 - 本题（判断子序列） ：
s必须完全被t吃进去。如果s[i-1]和t[j-1]不相等，我绝对不能丢掉s[i-1]，因为s少了任何一个字符就不算子序列了。我只能寄希望于t往前找，看看t前面的字符能不能匹配上s。所以，只能看左边dp[i][j-1]，完全无视上边dp[i-1][j]。
2. 返回值的巧妙转换
正常 DP 求的是具体数值，但这题问的是 bool。
不需要写复杂的判断，直接看最终算出来的公共长度 dp[n][m] 有没有把 s 全部"消化"掉（即 == n）。一行代码完成类型转换。
3. 最优解：双指针
虽然这题用 DP 完全正确，但因为它具有"单向匹配"的特性，其实用**双指针（O(1)空间）**更符合直觉：
cpp
int i = 0, j = 0;
while(i < s.size() && j < t.size()) {
if(s[i] == t[j]) i++; // s 匹配成功，往后走
j++; // t 无论匹没匹配成功，都必须往后找
}
return i == s.size();