0011算法笔记——【动态规划】最长公共子序列问题(LCS)
算法,最长公共子序列
最长公共子序列（LCS）问题（非连续子序列）的两种解法最长公共子序列也称作最长公共子串，英文缩写是LCS（Longest Common Subsequence）。
其定义是：一个序列S，如果分别是两个或多个已知序列的子序列，且是符合此条件的子序列中最长的，则称S为已知序列的最长公共子序列。
关于子序列的定义通常有两种方式，一种是对子序列没有连续的要求，其子序列的定义就是原序列中删除若干元素后得到的序列。
另一种是对子序列有连续的要求，其子序列的定义是原序列中连续出现的若干个元素组成的序列。
求解子序列是非连续的最长公共子序列问题是一个十分实用的问题，它可以描述两段文字之间的“相似度”，即它们的雷同程度，从而能够用来辨别抄袭。
本文将介绍对子序列没有连续性要求的情况下如何用计算机解决最长公共子序列问题，对子序列有连续性要求的情况下如何用计算机解决最长公共子序列问题将在后续的文章中介绍。
一、动态规划法（Dynamic Programming）最长公共子序列问题应该是属于多阶段决策问题中求最优解一类的问题，凡此类问题在编制计算机程序时应优先考虑动态规划法，如果不能用动态规划法，而且也找不到其它解决方法，还可以考虑穷举法。
对于这个问题，只要能找到描述最长公共子序列的最优子结构和最优解的堆叠方式，并且保证最优子结构中的每一次最优决策都满足“无后效性”，就可以考虑用动态规划法。
使用动态规划法的关键是对问题进行分解，按照一定的规律分解成子问题（分解后的子问题还可以再分解，这是个递归的过程），通过对子问题的定义找出最优子结构中最优决策序列（对于子问题就是最有决策序列的子序列）以及最优决策序列子序列的递推关系（当然还包括递推关系的边界值）。
如果一个给定序列的子序列是在该序列中删去若干元素后得到的序列，也就意味着子序列在原序列中的位置索引（下标）保持严格递增的顺序。
例如,序列S = <B,C,D,B>是序列K = <A，B，C，B，D，A，B>的一个子序列（非连续），序列S的元素在在K中的位置索引I = [2,3,5,7]，I是一个严格递增序列。
动态规划法求解最长公共子序列(含Java代码)
公共子序列问题徐康123183一．算法设计假设有两个序列X和Y，假设X和Y分别有m和n个元素，则建立一个二维数组C[(m+1)*(n+1)]，记录X i与Y j的LCS的长度。
将C[i,j]分为三种情况：若i =0 或j =0时，C[i,j]=0；若i,j>0且X[i]=Y[j]，C[i,j]=C[i-1,j-1]+1；若i,j>0且X[i] Y[j],C[i,j]=max{C[i-1,j],C[i,j-1]}。
再使用一个m*n的二维数组b，b[i,j]记录C[i,j]的来向:若X[i]=Y[j]，则B[i,j]中记入“↖”，记此时b[i,j] = 1；若X[i] Y[j]且C[i-1,j] > C[i,j-1]，则b[i,j]中记入“↑”，记此时B[i,j] = 2；若X[i] Y[j]且C[i-1,j] < C[i,j-1]，则b[i,j]中记入“←”，记此时B[i,j] = 3；若X[i]Y[j]且C[i-1,j] = C[i,j-1]，则b[i,j]中记入“↑”或“←”，记此时B[i,j] = 4；得到了两个数组C[]和B[]，设计递归输出LCS(X,Y)的算法：LCS_Output(Direction[][], X[], i, j, len,LCS[]){If i=0 or j=0 将LCS[]保存至集合LCS_SET中then return;If b[i,j]=1 then /*X[i]=Y[j]*/{LCS_Output(b,X,i-1,j-1)；将X[i]保存至LCS[len-i]；}else if b[i,j]=2 then /*X[i]Y[j]且C[i-1,j]>C[i,j-1]*/LCS_Output(b,X,i-1,j)else if b[i,j]=3 then /*X[i]Y[j]且C[i-1,j]<C[i,j-1]*/ LCS_Output(b,X,i,j-1)else if b[i,j]=4 then /*X[i]Y[j]且C[i-1,j]=C[i,j-1]*/LCS_Output(b,X,i-1,j)LCS_Output(b,X,i,j-1)}二．算法时间复杂度分析由上述对算法的分析得知，求辅助数组C 和B 所消耗的时间复杂度为O （mn ），而查找所有的公共子序列的时间复杂度取决于所遍历的路径，而路径是由算法递归的方向决定的。
最长公共子序列算法
最长公共子序列算法最长公共子序列算法概述最长公共子序列（Longest Common Subsequence，LCS）是一种常见的字符串匹配问题。
给定两个字符串S和T，求它们的最长公共子序列，即在S和T中都出现的最长的子序列。
该问题可以用动态规划算法解决。
算法原理动态规划算法是一种将复杂问题分解成更小的子问题来解决的方法。
在LCS算法中，我们将两个字符串S和T分别看作X和Y，并定义一个二维数组c[i][j]表示X[1..i]和Y[1..j]的LCS长度。
则有以下递推公式：c[i][j] = 0, if i=0 or j=0c[i][j] = c[i-1][j-1]+1, if X[i]=Y[j]c[i][j] = max(c[i-1][j], c[i][j-1]), if X[i]!=Y[j]其中第一行和第一列均初始化为0，因为空字符串与任何字符串的LCS长度均为0。
当X[i]=Y[j]时，说明当前字符相同，那么当前字符可以加入到LCS中，所以LCS长度加1；否则当前字符不能加入到LCS中，则需要从上一个状态继承得到当前状态。
最终结果即为c[m][n]，其中m和n分别表示X和Y的长度。
算法实现以下是LCS算法的Python实现：def lcs(X, Y):m = len(X)n = len(Y)c = [[0] * (n+1) for i in range(m+1)]for i in range(1, m+1):for j in range(1, n+1):if X[i-1] == Y[j-1]:c[i][j] = c[i-1][j-1] + 1else:c[i][j] = max(c[i-1][j], c[i][j-1])return c[m][n]其中X和Y分别为两个字符串。
算法优化以上算法的时间复杂度为O(mn)，其中m和n分别表示X和Y的长度。
如果X和Y较长，算法会很慢。
但是我们可以通过一些优化来降低时间复杂度。
[DataStructure]LCSs——最长公共子序列和最长公共子串
![[DataStructure]LCSs——最长公共子序列和最长公共子串](https://img.taocdn.com/s3/m/dadfc86826d3240c844769eae009581b6bd9bde9.png)
[DataStructure]LCSs——最长公共⼦序列和最长公共⼦串1. 什么是 LCSs？ 什么是 LCSs? 好多博友看到这⼏个字母可能⽐较困惑，因为这是我⾃⼰对两个常见问题的统称，它们分别为最长公共⼦序列问题（Longest-Common-Subsequence）和最长公共⼦串（Longest-Common-Substring）问题。
这两个问题⾮常的相似，所以对不熟悉的同学来说，有时候很容易被混淆。
下⾯让我们去好好地理解⼀下两者的区别吧。
1.1 ⼦序列 vs ⼦串 ⼦序列是有序的，但不⼀定是连续，作⽤对象是序列。
例如：序列 X = <B, C, D, B> 是序列 Y = <A, B, C, B, D, A, B> 的⼦序列，对应的下标序列为 <2, 3, 5, 7>。
⼦串是有序且连续的，左右对象是字符串。
例如 a = abcd 是 c = aaabcdddd 的⼀个⼦串；但是 b = acdddd 就不是 c 的⼦串。
1.2 最长公共⼦序列 vs 最长公共⼦串 最长公共⼦序列和最长公共⼦串是常见的两种问题，虽然两者问题很相似，也均可以根据动态规划进⾏求解，但是两者的本质是不同的。
最长公共⼦序列问题是针对给出的两个序列，求两个序列最长的公共⼦序列。
最长公共⼦串问题是针对给出的两个字符串，求两个字符串最长的公共⼦串（有关字符串匹配相关算法可以转⾄博客《》）。
2. 动态规划⽅法求解LCSs 前⾯提到，动态规划⽅法均可以⽤到最长公共⼦序列和最长公共⼦串问题当中，在这⾥我们就不⼀⼀进⾏求解了。
我们以最长公共⼦序列为例，介绍⼀下如何利⽤动态规划的思想来解决 LCSs。
给定两个序列，找出在两个序列中同时出现的最长⼦序列的长度。
对于每⼀个序列⽽⾔，其均具有a m中⼦序列，因此采⽤暴⼒算法的时间复杂度是指数级的，这显然不是⼀种好的解决⽅案。
下⾯我们看⼀下，如何使⽤动态规划的思想来解决最⼤公共⼦序列问题。
最长公共子序列lcs算法
最长公共子序列lcs算法最长公共子序列（Longest Common Subsequence，简称LCS）算法是一种常用的字符串匹配算法，用于在两个字符串中找到最长的公共子序列。
在计算机科学领域，字符串匹配是一项基础性的任务，常用于文本比较、版本控制、DNA序列比对等领域。
LCS算法的基本思想是通过动态规划的方式，从头开始比较两个字符串的每个字符，逐步构建一个二维数组来保存公共子序列的长度。
具体步骤如下：1. 创建一个二维数组dp，大小为两个字符串长度加1。
dp[i][j]表示字符串1的前i个字符和字符串2的前j个字符的最长公共子序列的长度。
2. 初始化dp数组的第一行和第一列，即dp[0][j]和dp[i][0]都为0，表示一个空字符串与任何字符串的最长公共子序列长度都为0。
3. 从字符串的第一个字符开始，逐行逐列地比较两个字符串的字符。
如果两个字符相等，则说明这个字符属于最长公共子序列，将dp[i][j]的值设置为dp[i-1][j-1]+1。
如果两个字符不相等，则说明这个字符不属于最长公共子序列，取dp[i-1][j]和dp[i][j-1]中的较大值来更新dp[i][j]的值。
4. 最后，dp[m][n]即为两个字符串的最长公共子序列的长度，其中m和n分别为两个字符串的长度。
接下来，我们通过一个例子来演示LCS算法的具体过程。
假设有两个字符串str1="ABCDAB"和str2="BDCABA"，我们要找出这两个字符串的最长公共子序列。
创建一个二维数组dp，大小为(str1.length()+1)×(str2.length()+1)。
初始化dp数组的第一行和第一列为0。
```B DC A B AA 0 0 0 0 0 0B 0C 0D 0A 0B 0```从第一个字符开始比较，我们发现str1[1]和str2[1]都是B，因此dp[1][1]=dp[0][0]+1=1。
最长公共子序列问题
2.3最长公共子序列问题和前面讲的有所区别，这个问题的不涉及走向。
很经典的动态规划问题。
例题16最长公共子序列(lcs.pas/c/cpp)【问题描述】一个给定序列的子序列是在该序列中删去若干元素后得到的序列。
确切地说，若给定序列X= < x1, x2,…, xm>，则另一序列Z= < z1, z2,…, zk>是X的子序列是指存在一个严格递增的下标序列< i1, i2,…, ik>，使得对于所有j=1,2,…,k有Xij=Zj例如，序列Z=是序列X=的子序列，相应的递增下标序列为<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>，则序列是X和Y的一个公共子序列，序列也是X和Y的一个公共子序列。
而且，后者是X和Y的一个最长公共子序列，因为X和Y没有长度大于4的公共子序列。
给定两个序列X= < x1, x2, …, xm>和Y= < y1, y2, … , yn>，要求找出X和Y的一个最长公共子序列。
【输入文件】输入文件共有两行，每行为一个由大写字母构成的长度不超过200的字符串，表示序列X和Y。
【输出文件】输出文件第一行为一个非负整数，表示所求得的最长公共子序列的长度，若不存在公共子序列，则输出文件仅有一行输出一个整数0，否则在输出文件的第二行输出所求得的最长公共子序列(也用一个大写字母组成的字符串表示。
【输入样例】ABCBDABBDCBA【输出样例】4BCBA【问题分析】这个问题也是相当经典的。
这个题目的阶段很不明显，所以初看这个题目没什么头绪，不像前面讲的有很明显的上一步，上一层之类的东西，只是两个字符串而且互相没什么关联。
但仔细分析发现还是有入手点的：既然说是动态规划，那我们首先要考虑的就是怎么划分子问题，一般对于前面讲到的街道问题和数塔问题涉及走向的，考虑子问题时当然是想上一步是什么？但这个问题没有涉及走向，也没有所谓的上一步，该怎么办呢？既然是求公共子序列，也就有第一个序列的第i个字符和第二个序列的第j个字符相等的情况。
最长公共子序列问题LCS-Read
最长公共子序列问题LCS问题描述一个给定序列的子序列是在该序列中删去若干元素后得到的序列。
确切地说，若给定序列X=<x1, x2,…, x m>，则另一序列Z=<z1, z2,…, z k>是X的子序列是指存在一个严格递增的下标序列<i1, i2,…, i k>，使得对于所有j=1,2,…,k有例如，序列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, B, A>也是X和Y的一个公共子序列。
而且，后者是X和Y的一个最长公共子序列，因为X和Y没有长度大于4的公共子序列。
最长公共子序列(LCS)问题：给定两个序列X=<x1, x2, …, x m>和Y=<y1, y2, … , y n>，要求找出X和Y的一个最长公共子序列。
参考解答动态规划算法可有效地解此问题。
下面我们按照动态规划算法设计的各个步骤来设计一个解此问题的有效算法。
1.最长公共子序列的结构解最长公共子序列问题时最容易想到的算法是穷举搜索法，即对X的每一个子序列，检查它是否也是Y的子序列，从而确定它是否为X和Y的公共子序列，并且在检查过程中选出最长的公共子序列。
X的所有子序列都检查过后即可求出X和Y的最长公共子序列。
X 的一个子序列相应于下标序列{1, 2, …, m}的一个子序列，因此，X共有2m个不同子序列，从而穷举搜索法需要指数时间。
事实上，最长公共子序列问题也有最优子结构性质，因为我们有如下定理：定理: LCS的最优子结构性质设序列X=<x1, x2, …, x m>和Y=<y1, y2, …, y n>的一个最长公共子序列Z=<z1, z2, …,z k>，则：1.若x m=y n，则z k=x m=y n且Z k-1是X m-1和Y n-1的最长公共子序列；2.若x m≠y n且z k≠x m ，则Z是X m-1和Y的最长公共子序列；3.若x m≠y n且z k≠y n，则Z是X和Y n-1的最长公共子序列。
最长公共子序列 空间复杂度优化
最长公共子序列（LCS）是一种经典的字符串算法，用于找到两个字符串中最长的共同子序列。
在实际应用中，LCS算法被广泛用于文本相似度比较、版本控制系统、生物信息学等领域。
在本文中，我们将探讨LCS算法的空间复杂度优化，通过深入分析和讨论，帮助你更好地理解这一优化策略。
1. LCS算法概述LCS算法是一种动态规划算法，通过填表格的方式，将两个字符串的比对过程可视化，最终找到它们的最长公共子序列。
在最简单的情况下，LCS算法的时间复杂度为O(n*m)，其中n和m分别为两个字符串的长度。
但是，在实际应用中，我们通常不仅关注算法的时间复杂度，还需要考虑空间复杂度的优化。
2. 实现原理在传统的LCS算法中，我们通常使用一个二维数组来保存中间状态，以便回溯最长公共子序列。
然而，这种做法在空间上会占用较多的内存，尤其是当输入字符串较长时。
为了优化空间复杂度，我们可以采用一维数组来存储中间状态，从而减少内存的占用。
3. 空间复杂度优化具体来说，我们可以利用滚动数组的思想，只使用两个一维数组来交替保存当前行和上一行的状态。
这样做的好处是，我们可以不断地更新这两个数组，而不需要保存整个二维表格，从而减少了空间的占用。
通过这种优化策略，我们可以将空间复杂度降低到O(min(n, m))，显著减少了内存的使用。
4. 示例分析让我们通过一个简单的示例来说明空间复杂度优化的过程。
假设有两个字符串"ABCD"和"BACDB"，我们希望找到它们的最长公共子序列。
在传统的LCS算法中，我们需要使用一个二维数组来保存中间状态，而在空间复杂度优化后，我们只需要使用两个一维数组来交替保存状态。
通过这种优化，我们可以用较少的内存来解决相同的问题。
5. 个人观点空间复杂度优化是算法设计中非常重要的一环，尤其在处理大规模数据时尤为重要。
通过优化空间复杂度，我们可以节省内存的使用，提高算法的效率，同时也更好地适应了现代计算机的内存限制。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
问题描述：一个给定序列的子序列是在该序列中删去若干元素后得到的序列。
确切地说，若给定序列X= { x1, x2,…, x m}，则另一序列Z= {z1, z2,…, z k}是X的子序列是指存在一个严格递增的下标序列{i1, i2,…, i k}，使得对于所有j=1,2,…,k有X ij=Z j。
例如，序列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,B,A}也是X和Y的一个公共子序列。
而且，后者是X和Y的一个最长公共子序列，因为X和Y没有长度大于4的公共子序列。
给定两个序列X= {x1, x2, …, x m}和Y= {y1, y2, … , y n}，要求找出X和Y的一个最长公共子序列。
问题解析：设X= { A, B, C, B, D, A, B},Y= {B, D, C, A, B, A}。
求X，Y的最长公共子序列最容易想到的方法是穷举法。
对X的多有子序列，检查它是否也是Y的子序列，从而确定它是否为X和Y的公共子序列。
由集合的性质知，元素为m的集合共有2^m个不同子序列，因此，穷举法需要指数级别的运算时间。
进一步分解问题特性，最长公共子序列问题实际上具有最优子结构性质。
设序列X={x1,x2,……x m}和Y={y1,y2,……y n}的最长公共子序列为Z={z1,z2,……z k}。
则有：(1)若x m=y n,则z k=x m=y n,且z k-1是X m-1和Y n-1的最长公共子序列。
(2)若x m!=y n且z k!=x m，则Z是X m-1和Y的最长公共子序列。
(3)若x m!=y n且z k!=y n，则Z是X和Y n-1的最长公共子序列。
其中，X m-1={x1,x2……x m-1}，Y n-1={y1,y2……y n-1},Z k-1={z1,z2……z k-1}。
递推关系：用c[i][j]记录序列X i和Y j的最长公共子序列的长度。
其中，X i={x1,x2……x i}，Y j={y1,y2……y j}。
当i=0或j=0时，空序列是x i和y j的最长公共子序列。
此时，c[i][j]=0；当i,j>0，x i=y j时，c[i][j]=c[i-1][j-1]+1；当i,j>0，x i!=y j时，c[i][j]=max{c[i][j-1],c[i-1][j]}，由此建立递推关系如下：构造最优解：由以上分析可知，要找出X={x1,x2,……x m}和Y={y1,y2,……y n}的最长公共子序列,可以按一下方式递归进行：当x m=y n 时，找出x m-1和y n-1的最长公共子序列，然后在尾部加上x m(=y n)即可得X和Y的最长公共子序列。
当X m!=Y n时，必须解两个子问题，即找出X m-1和Y的一个最长公共子序列及X和Y n-1的一个最长公共子序列。
这两个公共子序列中较长者为X和Y的最长公共子序列。
设数组b[i][j]记录c[i][j]的值由哪一个子问题的解得到的，从b[m][n]开始，依其值在数组b中搜索，当b[i][j]=1时，表示X i和Y j的最长公共子序列是由X i-1和Y j-1的最长公共子序列在尾部加上x i所得到的子序列。
当b[i][j]=2时，表示X i和Y j的最长公共子序列与X i-1和Y j-1的最长公共子序列相同。
当b[i][j]=3时，表示X i和Y j的最长公共子序列与X i和Y j-1的最长公共子序列相同。
代码如下：[cpp]view plain copy1.//3d3-1 最长公共子序列问题2.#include "stdafx.h"3.#include <iostream>ing namespace std;5.6.const int M = 7;7.const int N = 6;8.9.void output(char *s,int n);10.void LCSLength(int m,int n,char *x,char *y,int **c,int **b);11.void LCS(int i,int j,char *x,int **b);12.13.int main()14.{15.//X={A,B,C,B,D,A,B}16.//Y={B,D,C,A,B,A}17.char x[] = {' ','A','B','C','B','D','A','B'};18.char y[] = {' ','B','D','C','A','B','A'};19.20.int **c = new int *[M+1];21.int **b = new int *[M+1];22.for(int i=0;i<=M;i++)23. {24. c[i] = new int[N+1];25. b[i] = new int[N+1];26. }27.28. cout<<"序列X："<<endl;29. output(x,M);30. cout<<"序列Y："<<endl;31. output(y,N);32.33. LCSLength(M,N,x,y,c,b);34.35. cout<<"序列X、Y最长公共子序列长度为："<<c[M][N]<<endl;36. cout<<"序列X、Y最长公共子序列为："<<endl;37. LCS(M,N,x,b);38. cout<<endl;39.}40.41.void output(char *s,int n)42.{43.for(int i=1; i<=n; i++)44. {45. cout<<s[i]<<" ";46. }47. cout<<endl;48.}49.50.void LCSLength(int m,int n,char *x,char *y,int **c,int **b)51.{52.int i,j;53.54.for(i=1; i<=m; i++)55. c[i][0] = 0;56.for(i=1; i<=n; i++)57. c[0][i] = 0;58.59.for(i=1; i<=m; i++)60. {61.for(j=1; j<=n; j++)62. {63.if(x[i]==y[j])64. {65. c[i][j]=c[i-1][j-1]+1;66. b[i][j]=1;67. }68.else if(c[i-1][j]>=c[i][j-1])69. {70. c[i][j]=c[i-1][j];71. b[i][j]=2;72. }73.else74. {75. c[i][j]=c[i][j-1];76. b[i][j]=3;77. }78. }79. }80.}81.82.void LCS(int i,int j,char *x,int **b)83.{84.if(i==0 || j==0)85. {86.return;87. }88.if(b[i][j]==1)89. {90. LCS(i-1,j-1,x,b);91. cout<<x[i]<<" ";92. }93.else if(b[i][j]==2)94. {95. LCS(i-1,j,x,b);96. }97.else98. {99. LCS(i,j-1,x,b);100. }101.}LCSLength函数在计算最优值时，分别迭代X，Y构造数组b,c。
设数组每个元素单元计算耗费时间O(1)，则易得算法LCSLength的时间复杂度为O(mn)。
在算法LCS中，依据数组b的值回溯构造最优解，每一次递归调用使i，或j减小1。
从而算法的计算时间为O(m+n)。
LCS 的回溯构造最优解过程如下图所示:算法的改进：对于一个具体问题，按照一般的算法设计策略设计出的算法，往往在算法的时间和空间需求上还可以改进。
这种改进，通常是利用具体问题的一些特殊性。
例如，在算法LCS_length和LCS中，可进一步将数组b省去。
事实上，数组元素c[i,j]的值仅由c[i-1][j-1]，c[i-1][j]和c[i][j-1]三个值之一确定，而数组元素b[i][j]也只是用来指示c[i][j]究竟由哪个值确定。
因此，在算法LCS中，我们可以不借助于数组b 而借助于数组c本身临时判断c[i][j]的值是由c[i-1][j-1]，c[i-1][j]和c[i][j-1]中哪一个数值元素所确定，代价是Ο(1)时间。
既然b对于算法LCS不是必要的，那么算法LCS_length便不必保存它。
这一来，可节省θ(mn)的空间，而LCS_length和LCS所需要的时间分别仍然是Ο(mn)和Ο(m+n)。
另外，如果只需要计算最长公共子序列的长度，则算法的空间需求还可大大减少。
事实上，在计算c[i][j]时，只用到数组c的第i 行和第i-1行。
因此，只要用2行的数组空间就可以计算出最长公共子序列的长度。
更进一步的分析还可将空间需求减至min(m, n)。
[cpp]view plain copy1.//3d3-2 最长公共子序列问题2.#include "stdafx.h"3.#include <iostream>ing namespace std;5.6.const int M = 7;7.const int N = 6;8.9.void output(char *s,int n);10.void LCSLength(int m,int n,char *x,char *y,int **c);11.void LCS(int i,int j,char *x,int **c);12.13.int main()14.{15.//X={A,B,C,B,D,A,B}16.//Y={B,D,C,A,B,A}17.char x[] = {' ','A','B','C','B','D','A','B'};18.char y[] = {' ','B','D','C','A','B','A'};19.20.int **c = new int *[M+1];21.for(int i=0;i<=M;i++)22. {23. c[i] = new int[N+1];24. }25.26. cout<<"序列X："<<endl;27. output(x,M);28. cout<<"序列Y："<<endl;29. output(y,N);30.31. LCSLength(M,N,x,y,c);32.33. cout<<"序列X、Y最长公共子序列长度为："<<c[M][N]<<endl;34. cout<<"序列X、Y最长公共子序列为："<<endl;35. LCS(M,N,x,c);36. cout<<endl;37.}38.39.void output(char *s,int n)40.{41.for(int i=1; i<=n; i++)42. {43. cout<<s[i]<<" ";44. }45. cout<<endl;46.}47.48.void LCSLength(int m,int n,char *x,char *y,int **c)49.{50.int i,j;51.52.for(i=1; i<=m; i++)53. c[i][0] = 0;54.for(i=1; i<=n; i++)55. c[0][i] = 0;56.57.for(i=1; i<=m; i++)58. {59.for(j=1; j<=n; j++)60. {61.if(x[i]==y[j])62. {63. c[i][j]=c[i-1][j-1]+1;64. }65.else if(c[i-1][j]>=c[i][j-1])66. {67. c[i][j]=c[i-1][j];68. }69.else70. {71. c[i][j]=c[i][j-1];72. }73. }74. }75.}76.77.void LCS(int i,int j,char *x,int **c)78.{79.if(i==0 || j==0)80. {81.return;82. }83.if(c[i][j]==c[i-1][j-1]+1)84. {85. LCS(i-1,j-1,x,c);86. cout<<x[i]<<" ";87. }88.else if(c[i-1][j]>=c[i][j-1])89. {90. LCS(i-1,j,x,c);91. }92.else93. {94. LCS(i,j-1,x,c);95. }96.}运行结果如下：从运行结果中可以看出，算法LCS回溯算法仅仅打印了其中一条最大公共子序列，如果存在多条公共子序列的情况下。