算法导论读书笔记（18）

最新推荐文章于 2021-10-25 20:28:27 发布

转载最新推荐文章于 2021-10-25 20:28:27 发布 · 319 阅读

算法导论专栏收录该内容

18 篇文章

订阅专栏

http://www.cnblogs.com/sungoshawk/p/3779740.html

算法导论读书笔记（18）

最长公共子序列

某给定序列的子序列，就是将给定序列中零个或多个元素去掉后得到的结果。其形式化定义如下：给定一个序列 X = < x₁ , x₂ , … , x_m >，另一个序列 Z = < z₁ , z₂ , … , z_k >，如果 Z 满足如下条件则称 Z 为 X 的 子序列 （subsequence），即存在一个严格递增的 X 的下标序列 < i₁ , i₂ , … , i_k >，对所有 j = 1，2，…， k ，满足 x_i_j = z_j 。给定两个序列 X 和 Y ，如果 Z 既是 X 的子序列，也是 Y 的子序列，则称它是 X 和 Y 的 公共子序列 。

最长公共子序列问题 （longest-common-subsequence problem）就是给定两个序列 X = < x₁ , x₂ , … , x_m >和 Y = < y₁ , y₂ , … , y_n >，求 X 和 Y 长度最长的公共子序列。简称LCS问题。下面将展示如何用动态规划方法高效求解LCS问题。

步骤1：描述最长公共子序列的特征

LCS问题符合最优子结构的性质。可以看到，子问题的自然分类对应两个输入序列的“前缀”对。前缀的严格定义如下：给定一个序列 X = < x₁ , x₂ , … , x_m>，对 i = 0，1，…， m ，定义 X 的第 i 前缀为 X_i = < x₁ , x₂ , … , x_i >， X₀ 为空串。

定理（LCS的最优子结构）

令 X = < x₁ , x₂ , … , x_m >和 Y = < y₁ , y₂ , … , y_n >为两个序列， Z = < z₁ , z₂ , … , z_k >为 X 和 Y 的任意LCS。
1. 如果 x_m = y_n ，则 z_k = x_m = y_n 且 Z_k_-1 是 X_m_-1 和 Y_n_-1 的一个LCS。
2. 如果 x_m ≠ y_n ，那么 z_k ≠ x_m 意味着 Z 是 X_m_-1 和 Y 的一个LCS。
3. 如果 x_m ≠ y_n ，那么 z_k ≠ y_n 意味着 Z 是 X 和 Y_n_-1 的一个LCS。

上面的定理说明两个序列的LCS包含两个序列的前缀的LCS。因此，LCS问题满足最优子结构性质。

步骤2：一个递归解

由定理可知，在求 X = < x₁ , x₂ , … , x_m >和 Y = < y₁ , y₂ , … , y_n >的一个LCS时，我们需要求解一个或两个子问题。如果 x_m = y_n ，我们应该求解 X_m_-1和 Y_n_-1 的一个LCS。然后将 x_m = y_n 追加到这个LCS的末尾，就得到 X 和 Y 的一个LCS。如果 x_m ≠ y_n ，我们必须求解两个子问题：求 X_m_-1 和 Y 的一个LCS与 X 和 Y_n_-1 的一个LCS。两个LCS中长的那个即为 X 和 Y 的一个LCS。

可以很容易看出LCS中的重叠子问题。为了求 X 和 Y 的一个LCS，我们可能需要求 X 和 Y_n_-1 的一个LCS以及 X_m_-1 和 Y 的一个LCS。这几个子问题都包含求解 X_m_-1 和 Y_n_-1 的LCS的子子问题。

设计LCS问题的递归算法还要建立最优解的递归式。令 c [ i , j ]表示 X_i 和 Y_j 的LCS的长度。如果 i = 0或 j = 0，即一个序列长度为0，那么LCS的长度为0。根据LCS问题的最优子结构性质，可知：

步骤3：计算LCS的长度

过程 LCS-LENGTH 接受两个序列 X = < x₁ , x₂ , … , x_m >和 Y = < y₁ , y₂ , … , y_n >为输入。它将 c [ i , j ]的值保存在表 c [ 0 .. m , 0 .. n ]，并按 行主次序（row-major order）计算表项（即首先由左至右计算 c 的第一行，然后第二行，依此类推）。过程还维护一个表 b [ 1 .. m , 1 .. n ]帮助构造最优解。 b [ i ,j ]指向的表项对应计算 c [ i , j ]时所选择的子问题的最优解。过程返回表 b 和表 c ， c [ m , n ]保存了 X 和 Y 的LCS的长度。

LCS-LENGTH(X, Y)
1  m = X.length
2  n = Y.length
3  let b[1..m, 1..n] and c[0..m, 0..n] be new tables
4  for i = 1 to n
5      c[i, 0] = 0
6  for j = 0 to n
7      c[0, j] = 0
8  for i = 1 to m
9      for j = 1 to n
10         if x_i == y_j
11             c[i, j] = c[i - 1, j - 1] + 1
12             b[i, j] = "↖"
13         elseif c[i - 1, j] >= c[i, j - 1]
14             c[i, j] = c[i - 1, j]
15             b[i, j] = "↑"
16         else
17             c[i, j] = c[i, j - 1]
18             b[i, j] = "←"
19 return c and b

下图显示了 LCS-LENGTH 对输入序列 X = < A , B , C , B , D , A , B >和 Y = < B , D , C , A , B , A >生成的结果。过程的运行时间为 Θ ( mn )，因为每个表项的计算时间为 Θ ( 1 )。

步骤4：构造LCS

现在可以用 LCS-LENGTH 返回的表 b 快速构造 X = < x₁ , x₂ , … , x_m >和 Y = < y₁ , y₂ , … , y_n >的LCS。

PRINT-LCS(b, X, i, j)
1 if i == 0 or j == 0
2     return
3 if b[i, j] == "↖"
4     PRINT-LCS(b, X, i - 1, j - 1)
5     print x_i
6 elseif b[i, j] == "↑"
7     PRINT-LCS(b, X, i - 1, j)
8 else
9     PRINT-LCS(b, X, i, j - 1)

LCS问题的简单Java实现

参考自http://www.cs.cityu.edu.hk/~lwang/cs5302/LCS.java

private static int[][] lcsLength(String x, String y) {
    int m = x.length();
    int n = y.length();
    int[][] b = new int[m + 1][n + 1];
    int[][] c = new int[m + 1][n + 1];
    for (int i = 0; i < n; i++)
        c[i][0] = 0;
    for (int j = 0; j < m; j++)
        c[0][j] = 0;
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            if (x.charAt(i - 1) == y.charAt(j - 1)) {
                c[i][j] = c[i - 1][j - 1] + 1;
                b[i][j] = DIAGONAL;
            } else if (c[i - 1][j] >= c[i][j - 1]) {
                c[i][j] = c[i - 1][j];
                b[i][j] = UP;
            } else {
                c[i][j] = c[i][j - 1];
                b[i][j] = FORWARD;
            }
        }
    }
    return b;
}

public static String getLCS(String x, String y) {
    int[][] b = lcsLength(x, y);
    String lcs = "";
    int i = x.length();
    int j = y.length();
    while (i != 0 && j != 0) {
        if (b[i][j] == DIAGONAL) {
            lcs = x.charAt(i - 1) + lcs;
            i = i - 1;
            j = j - 1;
        }
        if (b[i][j] == UP) {
            i = i - 1;
        }
        if (b[i][j] == FORWARD) {
            j = j - 1;
        }
    }
    return lcs;
}

private static final int DIAGONAL = 1;
private static final int UP = 2;
private static final int FORWARD = 3;