【动态规划】最长公共子序列

合集 - 动态规划(15)

1.【动态规划】最长公共子序列2022-11-15

2.【动态规划】最长递增子序列2022-11-193.【动态规划】子串、子序列问题2023-07-064.【动态规划】股票买卖问题2023-01-115.【动态规划】背包问题的应用2023-01-096.【动态规划】背包问题2023-01-037.【动态规划】矩阵2023-02-288.【动态规划】压缩状态2023-02-279.【动态规划】高楼扔鸡蛋问题2023-01-1710.【动态规划】打家劫舍2023-01-1611.【动态规划】博弈问题2023-01-1212.【动态规划】编辑距离2022-12-2613.【动态规划】正则表达式2024-01-2214.【动态规划】矩阵2024-01-2415.【动态规划】最长公共子串2024-02-05

收起

目录

• 最长公共子序列
• 应用
  • 应用1：Leetcode.1143
    • 题目
    • 解题思路
      • 初始状态
      • 状态转移
    • 代码
  • 应用2：Leetcode.583
    • 题目
    • 解题思路
    • 代码实现
      • 总结

最长公共子序列

最长公共子序列（Longest Common Subsequence），英文缩写为LCS，是动态规划中的经典问题。其定义是，一个序列 S，如果分别是两个或多个已知序列的子序列，且是所有符合此条件序列中最长的，则 S 称为已知序列的最长公共子序列。

典型应用如下：

序号	题目
1	1143. 最长公共子序列
2	583. 两个字符串的删除操作

应用

应用1：Leetcode.1143

题目

1143. 最长公共子序列

解题思路

我们使用动态规划求解，设 $dp[i][j]$ 表示字符串 $tex{t}_1$ 的前 $i$ 个字符，与字符串 $tex{t}_2$ 的前 $j$ 个字符的最长公共子序列。

即子串 $tex{t}_1[:i-1]$ 与 $tex{t}_2[:j-1]$ 的最长公共子序列的长度，注意，数组序号是从 $0$ 开始的，$i-1$ 表示前 $i$ 个字符。

初始状态

当其中一个字符串的长度为 $0$ 时，没有公共子序列，所以，任意一个字符长度为 $0$ 时，最长公共子序列的长度为 $0$ ，即：

$$\begin{array}{}\text{(1)}& dp[0][j]=0\text{(2)}& dp[i][0]=0\end{array}$$

状态转移

我们分别枚举两个字符串，会出现两种情况：

• 如果当前两个字符相等，那么当前状态 $dp[i][j]$ 就可以由上一个状态 $dp[i-1][j-1]$ 加 $1$ ；
• 如果当前两个字符不相等，那么当前状态 $dp[i][j]$ 就要从 $dp[i][j-1]$ 或者 $dp[i-1][j]$ 中取最大值。

所以，状态转移方程如下：

$$dp[i][j]=\{\begin{array}{ll}dp[i-1][j-1]+1,& tex{t}_1[i]=tex{t}_2[j]\\ max(dp[i][j-1],dp[i-1][j]),& tex{t}_1[i]\ne tex{t}_2[j]\end{array}$$

代码

class Solution:
    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        m, n = len(text1), len(text2)
        dp = [[0 for _ in range(n + 1)] for _ in range(m + 1)]
        for i in range(1, m + 1):
            for j in range(1, n + 1):
                # 如果当前两个字符串中的字符相等，则直接移动两个字符串的指针
                if text1[i -1] == text2[j - 1]:
                    dp[i][j] = dp[i - 1][j - 1] + 1
                else:
                    dp[i][j] = max(dp[i][j - 1], dp[i - 1][j])
        return dp[m][n]

应用2：Leetcode.583

题目

583. 两个字符串的删除操作

解题思路

先找到两个字符串的最长公共子序列，然后再用两个字符串的长度分别减去最长公共子序列长度，剩下的就是不相等的字符，即要删除字符。

算法的思路：

• 先求两个字符串的最长公共子序列；
• 需要删除的字符，就是公共子序列；

代码实现

class Solution:
    def minDistance(self, word1: str, word2: str) -> int:
        m, n = len(word1), len(word2)
        length = self.lcs(word1, word2)
        return m - length + n - length
 
    def lcs(self, text1: str, text2: str):
        m, n = len(text1), len(text2)
        dp = [[0 for _ in range(n + 1)] for _ in range(m + 1)]
        for i in range(1, m + 1):
            for j in range(1, n + 1):
                if text1[i - 1] == text2[j - 1]:
                    dp[i][j] = dp[i - 1][j - 1] + 1
                else:
                    dp[i][j] = max(dp[i][j - 1], dp[i - 1][j])
        return dp[m][n]

总结

动态规划的本质就是：枚举所有的状态，并寻找最优解。