最长公共子序列

最长公共子序列（Longest Common Subsequence，简称 LCS）的动态规划递归方程

可以这样理解：

设dp[i][j]表示两个字符串str1[0..i]和str2[0..j]的最长公共子序列的长度。

当str1[i] == str2[j]时，dp[i][j] = dp[i-1][j-1] + 1，即当前字符匹配，长度在之前的基础上增加 1。

当str1[i]!= str2[j]时，dp[i][j] = max(dp[i-1][j], dp[i][j-1])，即取左边或上边的最大值，因为当前字符不匹配，所以要从之前的情况中选择最优的。

通过这样逐步计算dp数组，最终就能得到最长公共子序列的长度。

我举个例子：

假设有两个字符串：`str1 = "ABCBDAB"` 和 `str2 = "BDCABA"`。

形象化推算一下，逐步计算 dp 数组：

		B	D	C	A	B	A
	0	0	0	0	0	0	0
A	0	0	0	0	1	1	1
B	0	1	1	1	1	2	2
C	0	1	1	2	2	2	2
B	0	1	2	2	2	3	3
D	0	1	2	2	2	3	3
A	0	1	2	2	3	3	4
B	0	1	2	3	3	4	4

可以看到，当两个字符相同时，dp[i][j] 等于 dp[i-1][j-1] + 1；当两个字符不同时，dp[i][j] 等于左边和上边中的较大值。

这样，最终 dp[7][7] 的值就是最长公共子序列的长度。

整个过程大致分为下面4个步骤：

1. 初始化：创建一个二维数组dp，并将其边界值设置为 0。在这个例子中，dp数组的大小为行列，其中和分别是两个字符串的长度。
2. 填充表格：按照动态规划的思路，从左上角开始，根据状态转移方程逐步填充dp数组。在这个例子中，状态转移方程为：
   • 如果当前两个字符相同（即s1.charAt(i-1) == s2.charAt(j-1)），则dp(i)(j) = dp(i-1)(j-1) + 1。
   • 如果当前两个字符不同（即s1.charAt(i-1)!= s2.charAt(j-1)），则dp(i)(j) = Math.max(dp(i-1)(j), dp(i)(j-1))。
3. 求解最长公共子序列长度：当填充完dp数组后，最长公共子序列的长度就是右下角的值，即dp[len1][len2]。
4. 回溯求解最长公共子序列：可以通过回溯dp数组来求解最长公共子序列的具体内容。具体方法是从右下角开始，根据dp数组中的值和状态转移方程，逐步回溯到左上角。在回溯过程中，记录下每个位置的字符，最终得到的就是最长公共子序列。

示例代码：

def longest_common_subsequence(str1, str2):
    # 创建二维数组 dp 来存储中间结果
    dp = [[0] * (len(str2) + 1) for _ in range(len(str1) + 1)]

    for i in range(1, len(str1) + 1):
        for j in range(1, len(str2) + 1):
            # 如果当前两个字符相同
            if str1[i - 1] == str2[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(str1)][len(str2)]

# 测试示例
str1 = "ABCBDAB"
str2 = "BDCABA"
print(longest_common_subsequence(str1, str2))  

在这个示例中，我们首先定义了一个名为longest_common_subsequence的函数，它接受两个字符串str1和str2作为参数，并返回它们的最长公共子序列的长度。在函数内部，我们使用二维数组dp来存储中间结果，并通过遍历str1和str2来计算dp数组的值。最后，我们返回右下角的值即为最长公共子序列长度。