LeetCode 1143. 最长公共子序列

题目描述

给定两个字符串 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 数组。

总结

这题的关键是把状态定义为两个字符串的前缀，而不是以某个字符结尾的字符串。

当当前字符相等时，继承左上角状态并加一；当当前字符不相等时，分别舍弃两个字符串的当前字符，取两条路径中的较大值。