【动态规划案例】彻底搞明白最长公共子序列LCS

浮点老韦

已于 2022-06-06 11:28:12 修改

阅读量581

点赞数 2

分类专栏：算法与设计文章标签：动态规划算法

于 2022-06-01 12:36:15 首次发布

本文链接：https://blog.csdn.net/weixin_47954860/article/details/125024736

版权

动态规划最长公共子序列子结构转移方程优化解

关键词由CSDN通过智能技术生成

算法与设计专栏收录该内容

5 篇文章 0 订阅

订阅专栏

最长公共子序列（LCS）

我们在写论文或者文章的时候，是否被判定为抄袭，其思想就是使用求最长公共子序列方法查找两篇文章相似度高不高。

子序列是指某个序列中任意地去掉若干个不一定连续的元素后形成的序列。如果一个元素也不去掉，其本身也是它的一个子序列。设序列X，Y：

$X=<x_{1},x_{2},x_{3},...,x_{m}>$

$Y=<y_{1},y_{2},y_{3},...,y_{k}>$

如果存在X的元素构成的严格递增序列，使得

$y_{j}=x_{i_{j}}, j=1,2,3,...,k$

则Y是X的一个子序列。

例如BDAB、ABCBDAB是ABCBDAB的一个子序列。

如果存在Z同时是X和Y的子序列，则称Z是X和Y的公共子序列。子序列的长度则是指子序列的元素个数。最长公共子序列问题就是在给定的 $X=<x_{1},x_{2},x_{3},...,x_{m}>$ 和 $Y=<y_{1},y_{2},y_{3},...,y_{k}>$ 序列中，求出这两个序列的最长公共子序列。

动态规划分析思路

如果用枚举法暴力求解，首先得列举出X所有的子序列，依次检查X的每个子序列是否在Y序列中出现。设 $Len(X)=m,Len(Y)=k$ ，m,k分别是X和Y序列元素个数。例如，

$X=AB$ ，子序列有3个<A,B,AB>，子序列个数 $2^{2}-1$ ；

$X=ABC$ ，子序列有7个<A,B,C,AB,AC,BC,ABC>，子序列个数 $2^{3}-1$ ；

$X=ABCD$ ，子序列有15个<A,B,C,D,AB,AC,AD,BC,BD,CD,ABC,ABD,ACD,BCD,ABCD>，子序列个数 $2^{4}-1$ ；

依次类推，暴力枚举算法下，得执行 $2^{m}-1$ 获取子序列，再执行 $k$ 次子序列是否在Y中出现，则最终求出所有子序列时间复杂度为 $O(2^{m}k)$ ，呈现指数级别的时间复杂度，速度那是相当的慢。如果用动态规划法去求最长公共子序列，那将是大大提高效率。

动态规划的一般步骤：

刻画出最优解的子结构；
确定动态转移方程；
自底向上计算出最优解；
根据全局最优解输出某一个最优解的值；

构造子结构

设序列X，Y，Z：

$X=<x_{1},x_{2},x_{3},...,x_{m}>$ ；

$Y=<y_{1},y_{2},y_{3},...,y_{n}>$ ；

$Z=<z_{1},z{2},z_{3},...,z_{k}>$ ，其中，Z是X和Y的一个最长公共子序列。

(1).如果 $x_{m}=y_{n}$ ，那么当 $z_{k}=x_{m}=y_{n}$ 时， $Z_{k-1}$ 是 $X_{m-1}$ 和 $Y_{n-1}$ 的一个最长公共子序列；

假如，X=ABDC，Y=KBADC，Z=BDC，等式 $z_{k}=x_{m}=y_{n}$ 意思就是X、Y、Z最后一个元素“C”相等。如下图所示：

此时 $Z_{k-1}$ =BD、 $X_{m-1}$ =ABD、 $Y_{n-1}$ =KBAD， $Z_{k-1}$ 是 $X_{m-1}$ 和 $Y_{n-1}$ 的一个最长公共子序列。

(2).如果 $x_{m}\neq y_{n}$ ，那么当 $z_{k}\neq x_{m}$ 时， $Z$ 将是 $X_{m-1}$ 和 $Y_{n}$ 的一个最长公共子序列；

假如，X=ABDCG，Y=KBADC，Z=BDC， $x_{m}\neq y_{n}$ 意思就是X最后一个元素“G”和Y最后一个元素“C”不相等，Z最后一个元素和X最后一个元素也不相等，如下图所示：

即 $z_{k}\neq x_{m}$ ，这样 $Z$ 肯定是 $X_{m-1}$ 和 $Y_{n}$ 的一个最长公共子序列。

(3).如果 $x_{m}\neq y_{n}$ ，那么当 $z_{k}\neq y_{n}$ 时， $Z$ 将是 $X_{m}$ 和 $Y_{n-1}$ 的一个最长公共子序列；

举个例子对这句话理解一下，比如X=ABDC，Y=KBADCG，Z=BDC，同样 $x_{m}\neq y_{n}$ 的意思就是X最后一个元素“G”和Y最后一个元素“C”不相等，Z最后一个元素和Y最后一个元素也不相等。如下图所示：

即 $z_{k}\neq y_{n}$ ，这样 $Z$ 肯定是 $X_{m}$ 和 $Y_{n-1}$ 的一个最长公共子序列。

确定转移方程

设 $lcs[i,j]$ 表示序列 $X=<x_{1},x_{2},x_{3},...,x_{i}>$ 和 $Y=<y_{1},y_{2},y_{3},...,y_{j}>$ 的最长公共子序列的长度，根据子结构的构造出以下方程：

这里主要是 $max\left \{ lcs[i-1][j],lcs[i][j-1] \right \}$ 比较难理解，但是结合下图一起思考，就能茅舍顿开了。

比如图中黑圈的是 $i=3,j=4$ ， $x_{i}=C$ , $y_{j}=A$ ，属于 $x_{i}\neq y_{j}$ 的情况，此时 $lcs[i,j]$ =2， $lcs[i-1][j]$ =1， $lcs[i][j-1]$ =2；看得出此时 $lcs[i][j-1]$ > $lcs[i-1][j]$ ，我们取红色矩形中的Y序列BDC和X序列ABC，那刚好有最长公共子序列BC；如果此时我们取蓝色矩形中的Y序列BDCA和X序列AB，那最长公共子序列只有A或者B。所以，我们取红色矩形的X和Y序列才正确。也就是说，在 $x_{i}\neq y_{j}$ 的情况下， $lcs[i,j]$ = $max\left \{ lcs[i-1][j],lcs[i][j-1] \right \}$ 取大的序列长度。

自底向上计算出最优解

根据上面的转移方程，设 $X=ABCBDAB$ 、 $Y=BDCABA$ 为例构造出一个二维表格，很直观的可以计算出最优解出来：

在这里得维护一个标记数组 $dir[i,j]$ 用来存储上面二维表递归路径的方向，输出结果如下：

$dir[i,j]$ ='↖'左上角方向，标记 $x_{i}=y_{j}$ ，此时剩余的最长公共子序列在 $Y_{j-1}$ 和 $X_{i-1}$ 序列中；

$dir[i,j]$ ='←↑'左上两边方向，标记 $lcs[i-1][j]$ = $lcs[i][j-1]$ ，此时剩余的最长公共子序列要么在 $Y_{j-1}$ 序列中，要么 $X_{i-1}$ 序列中；

$dir[i,j]$ ='←'向左方向，标记 $lcs[i][j-1]$ > $lcs[i-1][j]$ ，也就是说此时最长公共子序列在 $Y_{j-1}$ 和 $X_{i}$ 序列中。如下图所示，如果红色的框对应的就是 $Y_{j-1}$ 和 $X_{i}$ 序列。

$dir[i,j]$ ='↑'向上方向，标记 $lcs[i][j-1]$ < $lcs[i-1][j]$ ，也就是说此时最长公共子序列在 $X_{i-1}$ 和 $Y_{j}$ 序列中。如下图所示，如果红色的框对应的就是 $X_{i-1}$ 和 $Y_{j}$ 序列。

JavaScript求出最优解代码如下：

// 最长子序列
function lcsLength(str1, str2) {
    var ln1 = str1.length;
    var ln2 = str2.length;
    var lcs = [];
    var dir = [];
    for (var i = 0; i <= ln1; i++) {
        lcs[i] = [];
        lcs[i][0] = 0;
        dir[i] = [];
        dir[i][0] = -1;
    }
    for (var j = 0; j <= ln2; j++) {
        lcs[0][j] = 0;
        // b[0][j] = -1;
    }

    for (i = 1; i <= ln1; i++) {
        for (j = 1; j <= ln2; j++) {
            if (str1[i - 1] == str2[j - 1]) {
                lcs[i][j] = lcs[i - 1][j - 1] + 1;
                dir[i][j] = '↖';
            } else if (lcs[i - 1][j] > lcs[i][j - 1]) {
                lcs[i][j] = lcs[i - 1][j];
                dir[i][j] = "↑";
            } else if (lcs[i - 1][j] < lcs[i][j - 1]) {
                lcs[i][j] = lcs[i][j - 1];
                dir[i][j] = "←";
            } else {
                lcs[i][j] = lcs[i][j - 1];
                dir[i][j] = "←↑";
            }
        }
    }
    // lcss = lcs;
    // console.log(lcs);
    return dir;
}
var X = "ABCBDAB";
var Y = "BDCABA";
var lcsdirect = lcsLength(X, Y);

代码计算出的最长子序列长度为4，其实计算长度是没有难度的，最难是如何输出所有最长公共子序列，而且公共子序列不唯一，如何输出所有的公共子序列呢？

输出全局最优解

设置 $dir[i,j]$ 目的就是记忆求最长公共子序列长度过程中的路径方向跟踪，即当 $dir[i,j]$ ='↖'时，表示 $x_{i}=y_{j}$ 为LCS的其中一个元素。如下图所示：

从上图中 $dir[n1][n2]$ 开始递归遍历找到 $dir[i,j]$ ='↖'的路径。当递归结束时，可以看出得到三条路径，也就是说， $X=ABCBDAB$ 和 $Y=BDCABA$ 最长公共子序列应该有三条。用JavaScript输出所有最长子序列代码如下：

// tmpstr保存当前序列；
// lcsLen当前剩余的序列长度；
function print_cls(arr, str1, i, j, tmpstr, lcsLen) {
    if (i == 0 || j == 0) {
        console.log(tmpstr);
        return;
    } else if (arr[i][j] == '↖') {
        lcsLen = lcsLen - 1;
        tmpstr = str1[i - 1] + tmpstr;
        print_cls(arr, str1, i - 1, j - 1, tmpstr, lcsLen);
    } else if (arr[i][j] == "↑") {
        print_cls(arr, str1, i - 1, j, tmpstr, lcsLen);
    } else if (arr[i][j] == "←") {
        print_cls(arr, str1, i, j - 1, tmpstr, lcsLen);
    }
    else {
        print_cls(arr, str1, i, j - 1, tmpstr, lcsLen);
        print_cls(arr, str1, i - 1, j, tmpstr, lcsLen);
    }
}
print_cls(lcsdirect, X, X.length, Y.length, '', lcsdirect[X.length][Y.length]);

以上方法执行之后，可以输出3个最长子序列：

总结

为了理解动态规划求解子序列问题，我花了不少时间去理解和思考。直到今早醒来打开电脑把代码重新调试成功，断断续续用时差不多2天的时间才真正吃透子序列问题，必须好好写出这篇文章记录下来。自己脑瓜不灵光，只能花费更长时间去思考和理解。
看了很多动态规划例子，我觉得动态规划思想是一种抽象思维方式。理解动态规划需要跳出常规的技术思维，用一种自底向上的思维方式去思考。比如说求子序列问题，一般性思考可能会立马想到就是暴力枚举法，不断的for循环，一旦跳进这种思维陷阱，思路就没有章法了。当然这种思维需要通过案例不断的训练。