使用动态规划求解最长公共子序列（LCS）

1. 

最长公共子序列（LCS, Longest Common Subsequence）问题是一个经典的动态规划问题。它的目标是找到两个序列的最长子序列，这个子序列保持相对顺序但不要求是连续的。LCS 在很多实际场景中都有应用，比如文本比较、版本控制、基因序列比对等。

2. 问题定义

给定两个字符串 X 和 Y，我们需要找到它们的最长公共子序列。子序列是指从一个序列中删除一些元素（可以不删除）之后剩下的元素保持相对顺序。

例如，给定字符串 X = "ABCBDAB" 和 Y = "BDCAB"，它们的最长公共子序列是 "BDAB"，长度为 4。

2.1. 基本概念

子序列：在一个序列中删除零个或多个元素，但不改变剩下元素的相对顺序，称为该序列的子序列。最长公共子序列：给定两个序列，它们的公共子序列中最长的那一个即为它们的最长公共子序列。

3. 暴力解法

暴力解法的核心思想是通过递归遍历所有可能的子序列组合，然后判断哪些子序列是公共的，并返回最长的那个。这种方法直接利用递归，从两个字符串的最后一个字符开始比较，尝试去匹配每一对字符。

4. 动态规划解法

4.1. 状态定义

我们可以使用一个二维数组 dp[i][j] 来存储中间结果，其中 dp[i][j] 表示字符串 X 的前 i 个字符与字符串 Y 的前 j 个字符的最长公共子序列的长度。

即：

当 i == 0 或 j == 0 时，dp[i][j] = 0，因为任意字符串与空字符串的 LCS 长度为 0。

当 X[i-1] == Y[j-1] 时，dp[i][j] = dp[i-1][j-1] + 1。

否则，dp[i][j] = max(dp[i-1][j], dp[i][j-1])，表示考虑删除 X[i-1] 或 Y[j-1]。

4.2. 状态转移方程

根据以上定义，LCS 的递推关系如下：

例题：

1143. 最长公共子序列

给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

用例： abcde  和  ace        结果为3 

class Solution {
public:
    int longestCommonSubsequence(string text1, string text2) {
        int len_1 = text1.size();
        int len_2 = text2.size();
        // 使用动态规划来计算 LCS 长度
        vector<vector<int>> dp(len_1 + 1, vector<int>(len_2 + 1, 0));

        for (int i = 1; i <= len_1; ++i) {
            for (int j = 1; j <= len_2; ++j) {
                if (text1[i - 1] == text2[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[len_1][len_2];
    }
};
/*		a	b	c	d	e
						
a		1	1	1	1	1
c		1	1	2	2	2
e		1	1	2	2	3
*/

eg2:

[516. 最长回文子序列](https://leetcode.cn/problems/longest-palindromic-subsequence/)

给你一个字符串 `s` ，找出其中最长的回文子序列，并返回该序列的长度。

子序列定义为：不改变剩余字符顺序的情况下，删除某些字符或者不删除任何字符形成的一个序列。

这道题可以转变为 将字符串反转之后 和原字符串比较求最长的序列（因为可以删除）

class Solution {
public:
    int longestPalindromeSubseq(string s) {
        int len = s.size();
        string t = s;
        reverse(t.begin(), t.end());
        
        // 初始化动态规划数组
        int dp[len + 1][len + 1];
        for (int i = 0; i <= len; ++i) {
            dp[i][0] = 0;
            dp[0][i] = 0;
        }
        
        // 填充动态规划数组
        for (int i = 1; i <= len; ++i) {
            for (int j = 1; j <= len; ++j) {
                if (s[i - 1] == t[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[len][len];
    }
};

5. 总结

最长公共子序列问题是一个经典的动态规划问题，通过构建二维 dp 表，可以高效地计算两个字符串的最长公共子序列及其长度。动态规划算法的时间复杂度为 O(m × n)，在处理大规模输入时表现良好。