动态规划法求解最长公共子序列(含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]

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 ），而查找所有的公共子序列的时间复杂度取决于所遍历的路径，而路径是由算法递归的方向决定的。显然，最好的情况是m=n 并且B 中的所有值都为1（按斜对角线方向搜索），此时时间复杂度为O （n ）。当X 和Y 序列不存在公共子序列时为算法的最坏情况，因为此时C 数组的所有元素都为0，B 在每一个节点都要沿着两个不同的方向搜索，即每次都要调用两次LCS_Output,当调用到i=0或j=0时返回，直到搜索完整个m*n 数组才结束。

该时间复杂度就是计算从点（m,n ）到i=0或j=0的所有路径。建立如上图的直角坐标系，设点S （m ，n ）,x 轴上的坐标点P 1(1,0) 到Pm(m,0)，y 轴上的系列坐标点Q 1(0,1) 到Qn(0,n)。

因为j i Q P 和是搜索路径的边界上的点，点1+i P 不能直接到达点i P ，点1+j Q 也不能直接到达j Q ，所以点),(n m S 到m i P P P P ,...,,...,,21和n j Q Q Q Q ,...,,...,,21的路径数等价于),(n m S 到点

)1,('),...,1,('),...,1,2('),1,1('21m P i P P P m i 和点),1('),...,,1('),...,2,1('),1,1('21n Q j Q Q Q n j 的路径数，又因为

点),(n m 到),(j i 路径数为i

n j i n m C ---+，设总路径数为t ，则有

()()

m m

n n m n n m n n m n m m n n m n n n m m n m m n m m n m n n m n m

j j

m j

m n n

i i

n i

n m C C C C C C C C C C C C C C C C

t ++-+--+--+--+---+--+---+--+=--+-=--+-===+=+=+++++++++=+=∑∑11111110

11231201123121

11

1...... 三．程序流程图如下所示

四．程序源码

package Homework2;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStreamReader;

import java.util.HashSet;

import java.util.Set;

public class LCS {

int C[][];

int B[][];

Set LCS_SET = new HashSet(); //使用集合去重

public int LCSLength(char X[], char Y[]) { //返回公共子序列长度int m = X.length;

int n = Y.length;

C = new int[X.length][Y.length];

B = new int[X.length][Y.length];

for (int i = 0; i < m; i++) {

C[i][0] = 0;

B[i][0] = 0;

}

for (int j = 0; j < n; j++) {

C[0][j] = 0;

B[0][j] = 0;

}

for (int i = 1; i < m; i++) {

for (int j = 1; j < n; j++) {

if (X[i] == Y[j]) {

C[i][j] = C[i - 1][j - 1] + 1;

B[i][j] = 1;

} else if (C[i - 1][j] > C[i][j - 1]) {

C[i][j] = C[i - 1][j];

B[i][j] = 2;

} else if (C[i - 1][j] < C[i][j - 1]) {

C[i][j] = C[i][j - 1];

B[i][j] = 3;

} else {

C[i][j] = C[i - 1][j];

B[i][j] = 4;

}

}

}

return C[m - 1][n - 1];

}

public void LCS_Output(int Direction[][], char X[], int i, int j, int len, char LCS[]) {

int lcslen = len;

if (i == 0 || j == 0) {

LCS_SET.add(String.valueOf(LCS));

return;

}

if (B[i][j] == 1) {

LCS[len - 1] = X[i];

len--;

LCS_Output(B, X, i - 1, j - 1, len, LCS);

} else if (B[i][j] == 2) {

LCS_Output(B, X, i - 1, j, len, LCS);

} else if (B[i][j] == 3) {

LCS_Output(B, X, i, j - 1, len, LCS);

} else if (B[i][j] == 4) {

LCS_Output(B, X, i - 1, j, len, LCS);

LCS_Output(B, X, i, j - 1, len, LCS);

}

}

/**

*@param args

*/

public static void main(String[] args) throws IOException { // TODO Auto-generated method stub

char X[], Y[];

BufferedReader buf = null;

buf = new BufferedReader(new InputStreamReader(System.in));

System.out.println("请输入一个序列");

X = buf.readLine().toCharArray();

char X_temp[] = new char[X.length + 1];

for (int i = 0; i < X.length; i++) {

X_temp[0] = ' ';

X_temp[i + 1] = X[i];

}

System.out.println("请输入一个序列");

Y = buf.readLine().toCharArray();

char Y_temp[] = new char[Y.length + 1];

for (int i = 0; i < Y.length; i++) {

Y_temp[0] = ' ';

Y_temp[i + 1] = Y[i];

}

System.out.print("X=");

for (char x : X) {

System.out.print(x);

}

System.out.println();

System.out.print("Y=");

for (char y : Y) {

System.out.print(y);

}

System.out.println();

LCS lcs = new LCS();

int len = lcs.LCSLength(X_temp, Y_temp);

char LCS[] = new char[len];

int m = X.length;

int n = Y.length;

System.out.println("最长公共子序列长度为:" + len); // 输出最长子序列长度System.out.print("最长公共子序列有：");

lcs.LCS_Output(lcs.B, X_temp, m, n, len, LCS);

System.out.print(lcs.LCS_SET); // 输出子序列集合中的元素}

}

五．运行结果截图

1.输入abc和acb

2.输入asd和xcv

3.输入ABCBDAB 和BDCABA

经检查输出结果均正确！