【啃不完的算法导论】- 动态规划 - 最长公共子序列（概念篇）

　　以下内容纯是为了熟悉《算法导论》中的内容，高手可略过，其中涉及的书本内容的版权归原作者、译者、出版社所有

　　==================================================================

　　求最长公共子序列，一个典型的 动态规划题 和 字符串处理算法，写在这里是希望自己以后能多来看看和改改，温故而知新，有时间的话再加入c/c++代码。

　　下面进入正题：

　　%% 什么是子序列？概念有点晕，不过拿来学习怎么来精确表达一种内容挺好 %%

　　一个给定序列的子序列就是该给定序列中去掉零个或者多个元素。以形式化的方式来说，给定一个序列X=<x1, x2, ..., xm>，另一个序列Z=<z1, z2, ..., zk>是X的一个子序列，如果存在X的一个严格递增下标序列<i1, i2, ..., ik>，使得对所有的j=1, 2, ..., k，有Xij=zj。例如，Z=<B, C, D, B>是X=<A, B, C, B, D, A, B>的一个子序列，相应的下标序列为<2, 3, 5, 7>。

　　%% 什么是（最长）公共子序列？概念还是有点晕 %%

　　给定两个序列X和Y，称序列Z是X和Y的公共子序列，如果Z既是X的一个子序列又是Y的一个子序列。例如，如果X=<A, B, C, B, D, A, B>，Y=<B, D, C, A, B, A>，则序列<B, C, A>即为X和Y的一个公共子序列。但是序列<B, C, A>不是X和Y的一个最长公共子序列(Longest-Common-Subsequence, LCS)，因为它的长度等于3，而同为X和Y的公共子序列<B, C, B, A>其长度等于4。序列<B, C, B, A>是X和Y的一个LCS，序列<B, D, A, B>也是，因为没有长度为5或更大的公共子序列。

　　在最长子序列问题中，给定了两个序列X=<x1, x2, ..., xm>和Y=<y1, y2, ..., yn>，希望找出X和Y的最大长度公共子序列。

　　步骤1：描述一个最长公共子序列

　　%% 枚举方法没试过 %%

　　解决LCS问题的一种强力方法是枚举出X的所有子序列，然后逐一检查看其是否为Y的子序列，并随时记录发现的最长子序列。X的每个子序列对应于X的下标集{1, 2, ..., m}的一个子集。X共有2m个子序列，因此这种方法需要指数时间，这对长序列来说是不实际的。

　　%% 可以想想“最优子结构性质”是怎么描述的 %%

　　然而LCS问题具有最优子结构性质，下面的定理说明了这一点。我们将看到，子问题的自然类对应于两个输入序列的成对“前缀”。（%% 自然类是什么？ %%）准确的说，给定一个序列X=<x1, x2, ..., xm>，对i=0, 1, ..., m，定义X的第i个前缀为Xi=<x1, x2, ..., xi>。例如，如果X=<A, B, C, B, D, A, B>，则X4=<A, B, C, B>，而X0空序列。

　　%% 最长公共子序列的最优子结构的准确描述 %%

　　定理(LCS的最优子结构)：

　　设X=<x1, x2, ..., xm>和Y=<y1, y2, ..., yn>为两个序列，并设Z=<z1, z2, ..., zk>为X和Y的任意一个LCS。

　　%% LCS可能不只有一个，如a,b,c和a,c,b %%

　　%% 从xm，yn开始比较，是为了递归定义 %%

　　1) 如果xm=yn，那么zk=xm=yn而且Zk-1是Xm-1和Yn-1的一个LCS。

　　2) 如果xm≠yn，那么zk≠xm蕴含Z是Xm-1和Y的一个LCS。

　　3) 如果xm≠yn，那么zk≠yn蕴含Z是X和Yn-1的一个LCS。

　　1,2,3证明略。 %% 证明是《算法导论》里比较繁琐的一块内容，不过仔细看看过程很精彩 %%

　　步骤2：一个递归解

　　%% 重叠子问题在动态规划中很常见 %%

　　由上述定理可以知道，在找X=<x1, x2, ..., xm>和Y=<y1, y2, ..., yn>的一个LCS时，可能要检查一个或两个子问题。如果xm=yn，必须找出Xm-1和Yn-1的一个LCS。将xm=yn添加到这个LCS上，可以产生X和Y的一个LCS。如果xm≠yn，就必须解决两个子问题：找出Xm-1和Y的一个LCS，以及找出X和Yn-1的一个LCS。这两个LCS中，较长的就是X和Y的一个LCS，因为这些情况涉及了所有的可能，其中一个最优的子问题解必须被使用在X和Y的一个LCS中。

　　可以很容易地看出LCS问题中的重叠子问题性质。为找出X和Y的一个LCS，可能需要找出X和Yn-1的一个LCS以及Xm-1和Y的一个LCS。但这两个子问题都包含着找Xm-1和Yn-1的一个LCS的子子问题。还有许多其他的子问题共享子子问题。

　　%% 递归式看着容易理解，要自己写的时候老是记不起来 %%

　　像在矩阵链乘法问题中一样，LCS问题的递归解涉及到建立一个最优解的值的递归式。定义c[i, j]为序列Xi和Yi的一个LCS长度。如果i=0或j=0，其中一个的序列长度为0，因此LCS的长度为0。由LCS问题的最优子结构可得递归式

　　c[i, j] = 0　　　　　　　　　　　　　 如果 i=0 或 j=0

　　　　　= c[i-1, j-1] + 1　　　　　　　如果 i, j>0 和 xi=yi　　%% 第i个字符满足条件，加到子序列中，长度加1 %%

　　　　　= max( c[i, j-1], c[i-1, j] )　　如果 i, j>0 和 xi≠yi　　%% 第i个字符不一样了，根据前面的计算结果来比较哪个长一点，再取值%%

　　%% 下面的这个“子问题因为原问题的条件而被排除”没怎么明白，是条件不同考虑的子问题不同？ %%

　　观察这个递归公式，问题的一个条件限制了我们可能考虑的子问题。当xi=yi时，可以而且应该考虑寻找Xi-1和Yi-1的LCS的子问题。否则，应另外考虑寻找Xi和Yj-1以及Xi-1和Yj的LCS的两个子问题。在前面已经讨论的动态规划算法（装配线调度和矩阵链乘法）中，没有任何子问题因为原问题的条件而被排除。寻找LCS不是唯一的因为问题的条件而排除子问题的动态规划算法。例如，编辑距离也具有这个特征。

　　步骤3：计算LCS的长度

　　%% 自底向上的方法，一般是多重循环 %%

　　根据公式，可以很容易地写出一个指数时间的递归算法，来计算两个序列的LCS的长度。因为只有Θ(mn)个不同的子问题，所以可以用动态规划来自底向上计算解。

　　%% c表用来记录LCS的长度，b表用来跟踪当前选择的最优解，方便结束时构造出来LCS %%

　　过程LCS-LENGTH以两个序列X=<x1, x2, ..., xm>和Y=<y1, y2, ..., yn>为输入。它把c[i, j]值填入一个按行计算表项的表c[0..m, 0..n]中。（也就是，c的第一行从左到右填入，然后开始第二行，等等）。它还维护表b[0..m, 0..n]以简化最优解的构造。从直觉上看，b[i, j]指向一个表项，对应于在计算c[i, j]时所选择的最优子问题的解。该程序返回表b和c；c[m, n]包含X和Y的一个LCS的长度。

　　%% 有了递归式，代码就简单了，说明先定义递归式有多重要 %%

　　伪代码如下：

　　

View Code

// PRINT-LCS(b, X, i, j)
//
// if i=0 or j=0
//     then return
// if b[i, j] = left-up //指向左上方
//     then PRINT-LCS(b, X, i-1, j-1)
//         print xi
// else if b[i, j] = up //指向上方
//     then PRINT-LCS(b, X, i-1, j)
// else PRINT-LCS(b, X, i, j-1) //指向左边

　　对图中的表b，此程序输出“B C B A”。因为在递归的每个阶段i和j至少有一个要减小，故该过程的运行时间为O(m+n)。

　　改进代码

　　一旦设计出某个算法之后，常常可以在时间或者空间上对该算法做些改进。对直观的动态规划算法来说尤其如此，有些改变可以简化代码并改进一些常数因子，但并不会带来算法性能方面的渐进改善。其他一些改变则可以在时间和空间上有相当大的渐进节省。

　　%% 完全去掉表b（箭头表）没试过这种方法。 %%

　　例如，我们可以完全去掉表b。每个表项c[i, j]仅依赖于另外三个c表项：c[i-1, j-1]，c[i-1, j]和c[i, j-1]。给定c[i, j]的值，我们可以在O(1)时间内确定这三个值中的哪一个被用来计算c[i, j]的，而不检查表b。这样，利用一个类似于PRINT-LCS的过程，在O(m+n)时间内即可重构一个LCS。（练习中要求伪代码）。虽然用这种方法节省了Θ(mn)空间，但计算一个LCS时所需要的辅助空间并没有渐进地减少，因为表c总是需要占据Θ(mn)空间的。

　　%% 渐进空间需求？ 计算长度的话，表c实际上是只有两行有用，也没试过这种方法，不过要构造LCS还是需要一定的辅助信息 %%

　　然而，我们能减少LCS-LENGTH的渐进空间需求，因为它一次只需表c的两行：正在被计算的一行和前面一行（实际上，仅需略多于表c一行的空间就可以计算一个LCS的长度。）。如果仅要求出一个LCS的长度，则这种改进是有用的；如果要重构一个LCS的元素，则小的表无法包含足够的信息来使我们在O(m+n)时间内重新执行以前各步。