99 最长公共子序列LCS（Longest Common Subsequence）

1 题目

题目：最长公共子序列LCS（Longest Common Subsequence）
描述：给出两个字符串，找到最长公共子序列(LCS)，返回LCS的长度。

最长公共子序列的定义：
最长公共子序列问题是在一组序列（通常2个）中找到最长公共子序列（注意：不同于子串，LCS不需要是连续的子串）。该问题是典型的计算机科学问题，是文件差异比较程序的基础，在生物信息学中也有所应用。

lintcode题号——77，难度——medium

样例1：

输入：
A = "ABCD"
B = "EDCA"
输出：1
解释：LCS是 'A' 或 'D' 或 'C'

样例2：

输入：
A = "ABCD"
B = "EACB"
输出：2
解释：LCS 是 "AC" 或 "AB"

2 解决方案

2.1 思路

  使用动态规划的方式解，将状态dp[i][j]定义为表示A中前i个字符与B中前j个字符的最长公共子序列长度，则如果A中第i个字符与B中第j个字符相同，则dp[i][j]取以下三项中的最大值dp[i][j - 1]、dp[i - 1][j]、dp[i - 1][j - 1] + 1；如果A中第i个字符与B中第j个字符不同，则dp[i][j]取以下两项中的较大值dp[i][j - 1]、dp[i - 1][j]，理清动态规划的四要素即可解出。

双序列型动态规划：由于将状态定义成前i个字符的状态，所以前0个对象的状态~前i个对象的状态，一共有i+1个状态，所以容器的长度需要增加一位，注意与坐标型动态规划区分。

2.3 时间复杂度

  算法会遍历二维数组，假设A字符串和B字符串的长度分别为m、n，则算法的时间复杂度为O(m*n)。

2.4 空间复杂度

  使用了二维数组数据结构，容量为m*n，空间复杂度为O(m*n)。

3 源码

细节：

1. 动态规划的四要素：状态、方程、初始化、答案。（四要素在之前的题目数字三角形¹中有详细介绍）
2. 状态：用dp[i][j]表示A中前i个字符与B中前j个字符的最长公共子序列长度。
3. 方程：分两种情况，如果A中第i个字符与B中第j个字符相同，则dp[i][j]取以下三项中的最大值dp[i][j - 1]、dp[i - 1][j]、dp[i - 1][j - 1] + 1；如果A中第i个字符与B中第j个字符不同，则dp[i][j]取以下两项中的较大值dp[i][j - 1]、dp[i - 1][j]。
4. 初始化：其中一个字符串的前0个字符与另一个的任意前n个字符的最长公共子序列都为0。
5. 答案：A中所有字符与B中所有字符的最长公共子序列长度，即dp[maxI]dp[maxJ]。

C++版本：

/**
* @param A: A string
* @param B: A string
* @return: The length of longest common subsequence of A and B
*/
int longestCommonSubsequence(string &A, string &B) {
    // write your code here
    if (A.empty() || B.empty())
    {
        return 0;
    }

    // 状态：dp[i][j]表示A中前i个字符与B中前j个字符的最长公共子序列长度
    vector<vector<int>> dp(A.size() + 1, vector<int>(B.size() + 1, 0));

    // 初始化：其中一个字符串的前0个字符与另一个的任意前n个字符的最长公共子序列都为0
    for (int i = 0; i < dp.size(); i++)
    {
        dp[i][0] = 0;
    }
    for (int j = 0; j < dp.front().size(); j++)
    {
        dp[0][j] = 0;
    }

    for (int i = 1; i < dp.size(); i++)
    {
        for (int j = 1; j < dp.front().size(); j++)
        {
            // 方程：如果A中第i个字符与B中第j个字符相同，则dp[i][j]取max(dp[i][j - 1], dp[i - 1][j], dp[i - 1][j - 1] + 1)
            if (A[i-1] == B[j-1]) // 第i个字符下标为i-1
            {
                dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]);
                dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 1);
            }
            else // 方程：如果A中第i个字符与B中第j个字符不同，则dp[i][j]取max(dp[i][j - 1], dp[i - 1][j])
            {
                dp[i][j] = max(dp[i][j - 1], dp[i - 1][j]);
            }
        }
    }

    return dp[dp.size() - 1][dp.front().size() - 1]; // 答案：A中所有字符与B中所有字符的最长公共子序列长度
}

---

1. 数字三角形：https://blog.csdn.net/SeeDoubleU/article/details/124678103 ↩︎