首先定义一个给定序列的子序列,就是将给定序列中零个或多个元素去掉之后得到的结果,其形式化定义如下:给定一个序列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的子序列,则称它是X和Y的公共子序列。
最长公共子序列问题(longest-common-subsequence problem)可用动态规划方法高效地求解。
步骤1:刻画最长公共子序列的特征
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为空串。
令X = <x1,x2 ,..., xm>和Y = <y1,y2 ,..., yn> 为两个序列,Z =<z1,z2 ,..., zk>为X和Y的任意LCS。
- 如果Xm = Yn,则 Zk = Xm = Yn且Zk-1 是Xm-1和Yn-1的一个LCS。
- 如果 Xm ≠ Yn,那么Zk ≠ Xm意味着Z是Xm-1和Y的一个LCS。
- 如果 Xm ≠ Yn,那么Zk ≠ Yn意味着Z是X和Yn-1的一个LCS。
步骤2:一个递归解
很容易看出LCS问题的重叠子问题性质。为了求X和Y的一个LCS,我们可能需要求X和Yn-1的一个LCS及Xm-1和Y的一个LCS。但是这几个子问题都包含求解Xm-1和Yn-1的LCS的子子问题。我们定义c[i,j]表示Xi和Yj的LCS的长度。如果i= 0 或j = 0,即一个序列长度为0,那么LCS的长度为0,根据LCS问题的最优子结构性质,可得如下公式:
步骤3:计算LCS的长度
过程LCS-LENGTH接受两个序列X = <x1,x2 ,..., xm>和Y = <y1,y2 ,..., yn>为输入。它将c[i,j]的值保存在表c[0...m,0...n]中,过程还维护一个表b[1...m,1...n],帮助构造最优解。b[i,j]指向的表项对应计算c[i,j]时所选择的子问题最优解。过程返回表b和表c,c[m,n]保存了X和Y的长度。
//伪代码
LCS-LENGTH(X,Y)
m = X.length
n = Y.length
let b[1..m,1..n] and c[0..m,0..n]be new tables
for i = 1 to m
c[i,0] = 0
for j = 0 to n
c[0,j] = 0
for i = 1 to m
for j = 1 to n
if xi == yi
c[i,j] = c[i-1,j-1] + 1
b[i,j] = "↖"
else if c[i-1,j] ≥ c[i,j-1]
c[i,j] = c[i-1,j]
b[i,j] = "↑"
else
c[i,j] = c[i,j-1]
b[i,j] = "←"
return c and b
下图显示了LCS-LENGTH对输入序列X= <A,B,C,B,D,A,B>和Y=<B,D,C,A,B,A>生成的结果。过程的运行时间为O(mn)。
步骤4:构造LCS
利用LCS-LENGTH返回的表b快速构造X和Y的LCS,只需简单地从b[m,n]开始,并按箭头方向追踪下去即可。挡在表项b[i,j]中遇到一个”↖"时,意味着xi=yi是LCS的一个元素。下面的递归过程会按正确的顺序打印出X和Y的一个LCS。对它的起始调用为PRINT-LCS(b,X,X.length,Y.length)。
代码为:
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
//最长公共子序列问题
public class Lcs {
public static void main(String[] args) {
String X= "ABCBDAB";
String Y = "BDCABA";
System.out.println("序列X为:"+X);
System.out.println("序列Y为"+Y);
HashMap<String,int[][]> map = (HashMap<String, int[][]>) LCS_Length(X, Y);
int[][] c = map.get("result");
int[][] b = map.get("path");
System.out.println("动态规划结果表c为:");
for(int i=0;i<c.length;i++) {
for(int j=0;j<c[i].length;j++) {
System.out.print(c[i][j]+" ");
}
System.out.println();
}
System.out.println("动态规划结果表b为:");
for(int i=0;i<b.length;i++) {
for(int j=0;j<b[i].length;j++) {
System.out.print(b[i][j]+" ");
}
System.out.println();
}
System.out.println("X与Y最长公共子序列长度为:"+c[X.length()][Y.length()]);
System.out.println("X与Y最长公共子序列为:");
Print_Lcs(X, Y);
}
public static HashMap<String,int[][]> LCS_Length(String X,String Y) {
//将字符串转换为字符数组
char[] x = X.toCharArray();
char[] y = Y.toCharArray();
//m为序列X的长度,n为序列Y的长度
int m = x.length;
int n = y.length;
//c用于保存最长公共子序列的长度,c[i][j]代表序列X中前i个序列和Y中前j个序列的最长公共子序列长度
int[][] c = new int[m+1][n+1];
//b用于保存最长公共子序列的结构,b[i][j]代表计算c[i,j]时所选择的子问题最优解
int[][] b = new int[m+1][n+1];
//b中值只有3种:0,1,2
// b[i][j]=0 : 对应书中↖箭头
// b[i][j]=1 : 对应书中↑箭头
// b[i][j]=2 : 对应书中←箭头
for(int i=0;i<=m;i++) {
c[i][0]=0;
}
for(int j=0;j<=n;j++) {
c[0][j]=0;
}
for(int i=1;i<=m;i++) {
for(int j=1;j<=n;j++) {
//最优子结构公式
if(x[i-1] == y[j-1]) {
c[i][j] = c[i-1][j-1]+1;
b[i][j] = 0;
}else if(c[i-1][j]>=c[i][j-1]) {
c[i][j] = c[i-1][j];
b[i][j] = 1;
}else {
c[i][j] = c[i][j-1];
b[i][j] = 2;
}
}
}
HashMap<String,int[][]> map = new HashMap<String, int[][]>();
map.put("result", c);
map.put("path", b);
return map;
}
public static void Print_Lcs(String s1,String s2) {
HashMap<String, int[][]> map = LCS_Length(s1, s2);
int[][] c= map.get("result");
int[][] b= map.get("path");
Print_Lcs(b, s1.toCharArray(), s1.length(), s2.length());
}
private static void Print_Lcs(int[][] b,char[] x,int i,int j) {
if(i==0||j==0) {
return;
}
if(b[i][j]==0) {
Print_Lcs(b, x, i-1, j-1);
System.out.print(x[i-1]);
}else if(b[i][j]==1) {
Print_Lcs(b, x, i-1, j);
}else {
Print_Lcs(b, x, i, j-1);
}
}
}
运行结果: