数据结构【动态规划-二维数组】| leetcode 1143. 最长公共子序列(中等)

参考链接：

• https://leetcode-cn.com/problems/longest-common-subsequence/solution/zui-chang-gong-gong-zi-xu-lie-by-leetcod-y7u0/
• https://leetcode.cn/problems/longest-common-subsequence/solution/fu-xue-ming-zhu-er-wei-dong-tai-gui-hua-r5ez6/

LCS：long common substring

本题目可以应用于DNA领域。

最长公共子序列问题是典型的二维动态规划问题。

假设字符串 $\mathrm{tex}{\mathrm{t}}_1$ 和 $\mathrm{tex}{\mathrm{t}}_2$ 的长度分别为 $m$ 和 $n$，创建 $m+1$ 行 $n+1$ 列的二维数组 $dp$ ，其中 $dp[i][j]$ 表示 ${\text{text}}_1[0:i]$ 和 ${\text{text}}_2[0:j]$ 的最长公共子序列的长度。

上述表示中，${\text{text}}_1[0:i]$表示 $\mathrm{tex}{\mathrm{t}}_1$ 的长度为 $i$ 的前缀，${\text{text}}_2[0:j]$ 表示 $\mathrm{tex}{\mathrm{t}}_1$ 的长度为 $j$ 的前缀。

（注：${\text{text}}_1[0:i-1]$ 表示的是 ${\text{text}}_1$ 的 第 $0$ 个元素到第 $i-1$ 个元素，两端都包含）

之所以 $dp[i][j]$ 的定义不是 ${\text{text}}_1[0:i]$ 和 ${\text{text}}_2[0:j]$，是为了方便当 $i=0$ 或者 $j=0$ 的时候，$dp[i][j]$表示的为空字符串和另外一个字符串的匹配，这样 $dp[i][j]$可以初始化为 $0$。

考虑动态规划的边界情况：

• 当 $i=0$ 时，${\text{text}}_1[0:i]$ 为空，空字符串和任何字符串的最长公共子序列的长度都是 0 ，因此对任意 $0\le j\le n$ ，有 $dp[0][j]=0$；

• 当 $j=0$ 时，${\text{text}}_2[0:j]$ 为空，同理可得，对任意 $0\le i\le m$ ，有 $dp[i][0]=0$ 。

因此动态规划的边界情况是：当 $i=0$ 或 $j=0$ 时，$dp[i][j]=0$。

当 $i>0$ 且 $j>0$ 时，考虑 $dp[i][j]$ 的计算：

• 当 ${\text{text}}_1[i-1]={\text{text}}_2[j-1]$ 时，将这两个相同的字符称为公共字符，考虑 ${\text{text}}_1[0:i-1]$ 和 $\text{text}[0:j-1]$ 的最长公共子序列，再增加一个字符（即公共字符）即可得到 ${\text{text}}_1[0:i]$ 和 $\text{text}[0:j]$ 的最长公共子序列，因此 $dp[i][j]=dp[i-1][j-1]+1$。

• 当 ${\text{text}}_1[i-1]\ne tex{t}_2[j-1]$ 时，考虑以下两项：

  • ${\text{text}}_1[0:i-1]$ 和 ${\text{text}}_2[0:j]$ 的最长公共子序列；
  • ${\text{text}}_1[0:i]$ 和 ${\text{text}}_2[0:j-1]$ 的最长公共子序列。

要得到 ${\text{text}}_1[0:i]$ 和 ${\text{text}}_2[0:j]$ 的最长公共子序列，应取两项中的长度较大的一项，因此 $dp[i][j]=\max (dp[i-1][j],dp[i][j-1])$。

由此可以得到如下状态转移方程：

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

最终计算得到 $dp[m][n]$ 即为 $\mathrm{tex}{\mathrm{t}}_1$ 和 $\mathrm{tex}{\mathrm{t}}_2$ 的最长公共子序列的长度。

class Solution:
    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        dp = [[0] * (len(text2)+1) for _ in range(len(text1)+1)]

        for i in range(1, len(text1)+1):
            for j in range(1, len(text2)+1):
                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(text1)][len(text2)]

方法二：贪心 + 二分查找

考虑一个简单的贪心，如果我们要使上升子序列尽可能的长，则我们需要让序列上升得尽可能慢，因此我们希望每次在上升子序列最后加上的那个数尽可能的小。

基于上面的贪心思路，我们维护一个数组 $d[i]$，表示长度为 $i$ 的最长上升子序列的末尾元素的最小值，用 $len$ 记录目前最长上升子序列的长度，起始时 $len$ 为 1，$d[1]=\text{nums}[0]$。

同时我们可以注意到 $d[i]$ 是关于 $i$ 单调递增的。因为如果 $d[j]\ge d[i]$ 且 $j<i$，我们考虑从长度为 $i$ 的最长上升子序列的末尾删除 $i-j$ 个元素，那么这个序列长度变为 $j$，且第 $j$ 个元素 $x$（末尾元素）必然小于 $d[i]$，也就小于 $d[j]$。那么我们就找到了一个长度为 $j$ 的最长上升子序列，并且末尾元素比 $d[j]$ 小，从而产生了矛盾。因此数组 $d$ 的单调性得证。

我们依次遍历数组 $\text{nums}$ 中的每个元素，并更新数组 $d$ 和 $len$ 的值。如果 $\text{nums}[i]>d[\text{len}]$ 则更新 $len=len+1$，否则在 $d[1\dots len]$ 中找满足 $d[i-1]<\text{nums}[j]<d[i]$ 的下标 $i$，并更新 $d[i]=\text{nums}[j]$。

根据 $d$ 数组的单调性，我们可以使用二分查找寻找下标 $i$，优化时间复杂度。

最后整个算法流程为：

设当前已求出的最长上升子序列的长度为 $\text{len}$（初始时为 1），从前往后遍历数组 $\text{nums}$，在遍历到 $\text{nums}[i]$ 时：

如果 $\text{nums}[i]>d[\text{len}]$，则直接加入到 $d$ 数组末尾，并更新 $\text{len}=\text{len}+1$。

否则，在 $d$ 数组中二分查找，找到第一个比 $\text{nums}[i]$ 小的数 $d[k]$，并更新 $d[k+1]=\text{nums}[i]$。

以输入序列 [0, 8, 4, 12, 2] 为例：

第一步插入 0，d = [0]；

第二步插入 8，d = [0, 8]；

第三步插入 4，d = [0, 4]；

第四步插入 12，d = [0, 4, 12]；

第五步插入 2，d = [0, 2, 12]。

最终得到最大递增子序列长度为 3。