题目描述
给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。如果不存在公共子序列，返回 0。
子序列可以通过删除原字符串中的某些字符得到，但不能改变剩余字符的相对顺序。
例如，"ace" 是 "abcde" 的子序列，但 "aec" 不是。
最初思路
一开始尝试用两个下标扫描字符串：遍历 text1，如果当前字符和 text2 的当前字符相等，就让 j++，同时让答案加一。
这种方法相当于遇到第一个可匹配字符就立即选择它，是一种局部贪心。
问题出在哪里
最长公共子序列不要求当前字符一旦能匹配就必须立即使用。当前的选择可能影响后面的匹配。
例如：
text1 = "bl"
text2 = "yby"正确答案是 1，可以匹配公共子序列 "b"。如果扫描时先拿 text1 的 b 和 text2 开头的 y 比较，就需要考虑跳过 text2 开头的 y，而不是只沿着一条匹配路径继续向前。
因此，当两个当前字符不相等时，需要比较两种选择：
1. 舍弃 text1 的当前字符
2. 舍弃 text2 的当前字符正确思路
把问题转换为两个前缀字符串的最长公共子序列问题。这样每个状态都表示一个稳定的前缀范围，不会因为舍弃字符而改变状态含义。
状态定义
dp[i][j]：text1 的前 i 个字符和 text2 的前 j 个字符的最长公共子序列长度因为 i 和 j 表示字符数量，所以当前要比较的字符下标是：
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])其中：
dp[i - 1][j]：舍弃 text1[i - 1]
dp[i][j - 1]：舍弃 text2[j - 1]不能直接使用 dp[i - 1][j - 1]，因为同时舍弃两个字符可能错过更优结果。
手动模拟
以 text1 = "bl"、text2 = "yby" 为例：
当 text1 的 b 和 text2 开头的 y 不相等时：
dp[1][1] = max(dp[0][1], dp[1][0]) = 0
继续比较 text1 的 b 和 text2 的第二个字符 b：
dp[1][2] = dp[0][1] + 1 = 1后面即使继续比较 l，也不会让结果小于已经得到的 1，最终答案为 1。
初始化与遍历顺序
当其中一个字符串为空时，不存在公共子序列，因此：
dp[0][j] = 0
dp[i][0] = 0所以 dp 开成 (m + 1) x (n + 1)，并从 i = 1、j = 1 开始遍历。Java 中不匹配分支需要使用 dp[i - 1][j]，不能误写成不存在的 dq[i - 1][j]。
伪代码
下面的伪代码与后面的 Java 实现一一对应：
函数 longestCommonSubsequence(text1, text2):
w1 <- text1 转换为字符数组
w2 <- text2 转换为字符数组
dp <- 大小为 (w1.length + 1) x (w2.length + 1) 的数组
对 i 从 1 到 w1.length:
对 j 从 1 到 w2.length:
如果 w1[i - 1] 等于 w2[j - 1]:
dp[i][j] <- dp[i - 1][j - 1] + 1
否则:
dp[i][j] <- max(dp[i - 1][j], dp[i][j - 1])
返回 dp[w1.length][w2.length]Java 代码
class Solution {
public int longestCommonSubsequence(String text1, String text2) {
char[] w1 = text1.toCharArray();
char[] w2 = text2.toCharArray();
int[][] dp = new int[w1.length + 1][w2.length + 1];
for (int i = 1; i <= w1.length; i++) {
for (int j = 1; j <= w2.length; j++) {
if (w1[i - 1] != w2[j - 1]) {
dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1]);
} else {
dp[i][j] = dp[i - 1][j - 1] + 1;
}
}
}
return dp[w1.length][w2.length];
}
}易错点
1. 不能使用单次贪心匹配
当前字符相等时立即匹配，不一定能得到全局最优答案。需要让动态规划保留不同前缀选择的结果。
2. 不相等时不是同时舍弃两个字符
不相等时应该比较：
dp[i - 1][j] 和 dp[i][j - 1]分别对应舍弃 text1 或 text2 的当前字符。
3. 状态下标和字符下标不同
dp[i][j] 表示前 i 个和前 j 个字符，因此字符比较要使用 w1[i - 1] 和 w2[j - 1]。
4. 注意变量名笔误
不匹配分支使用的是同一个 dp 数组，不能写成 dq[i - 1][j]。
建议测试用例
text1 = "abcde", text2 = "ace" -> 3
text1 = "bl", text2 = "yby" -> 1
text1 = "", text2 = "abc" -> 0
text1 = "abc", text2 = "" -> 0
text1 = "abc", text2 = "abc" -> 3
text1 = "abc", text2 = "def" -> 0复杂度分析
- 时间复杂度：
O(m * n)，需要计算二维表中的每个状态。 - 空间复杂度：
O(m * n)，主要来自二维dp数组。
总结
这题的关键是把状态定义为两个字符串的前缀，而不是以某个字符结尾的字符串。
当当前字符相等时，继承左上角状态并加一；当当前字符不相等时，分别舍弃两个字符串的当前字符，取两条路径中的较大值。