用动态规划求解最长公共子序列和最长公共子串

        两个字符串求最长公共子序列和最长公共子串的最大区别就是最长公共子串要求连续，而最长公共子序列不连续。两者均可以采用动态规划思想求解。

       

【问题】 求两字符序列的最长公共字符子序列

问题描述：字符序列的子序列是指从给定字符序列中随意地（不一定连续）去掉若干个字符（可能一个也不去掉）后所形成的字符序列。令给定的字符序列X=“x0，x1，…，xm-1”，序列Y=“y0，y1，…，yk-1”是X的子序列，存在X的一个严格递增下标序列<i0，i1，…，ik-1>，使得对所有的j=0，1，…，k-1，有xij=yj。例如，X=“ABCBDAB”，Y=“BCDB”是X的一个子序列。

考虑最长公共子序列问题如何分解成子问题，设A=“a0，a1，…，am-1”，B=“b0，b1，…，bm-1”，并Z=“z0，z1，…，zk-1”为它们的最长公共子序列。不难证明有以下性质：

（1）如果am-1=bn-1，则zk-1=am-1=bn-1，且“z0，z1，…，zk-2”是“a0，a1，…，am-2”和“b0，b1，…，bn-2”的一个最长公共子序列；

（2）如果am-1!=bn-1，则若zk-1!=am-1，蕴涵“z0，z1，…，zk-1”是“a0，a1，…，am-2”和“b0，b1，…，bn-1”的一个最长公共子序列；

（3）如果am-1!=bn-1，则若zk-1!=bn-1，蕴涵“z0，z1，…，zk-1”是“a0，a1，…，am-1”和“b0，b1，…，bn-2”的一个最长公共子序列。

这样，在找A和B的公共子序列时，如有am-1=bn-1，则进一步解决一个子问题，找“a0，a1，…，am-2”和“b0，b1，…，bm-2”的一个最长公共子序列；如果am-1!=bn-1，则要解决两个子问题，找出“a0，a1，…，am-2”和“b0，b1，…，bn-1”的一个最长公共子序列和找出“a0，a1，…，am-1”和“b0，b1，…，bn-2”的一个最长公共子序列，再取两者中较长者作为A和B的最长公共子序列。

 

 

求解：

引进一个二维数组c[][]，用c[i][j]记录X[i]与Y[j] 的LCS 的长度，b[i][j]记录c[i][j]是通过哪一个子问题的值求得的，以决定搜索的方向。
我们是自底向上进行递推计算，那么在计算c[i,j]之前，c[i-1][j-1]，c[i-1][j]与c[i][j-1]均已计算出来。此时我们根据X[i] = Y[j]还是X[i] != Y[j]，就可以计算出c[i][j]。

问题的递归式写成：

而最长公共子串把递归式改一下：

          c[i , j] = 0  if xi≠yj

        c[i ,j] = c[i-1,j-1]+1   if i,j>0 and xi = yj

        c[i , j  = 1  if i=0 | | j=0 and xi = yj

回溯输出,最长公共子序列过程：

 

最长公共子串：

建立矩阵

--b  a  b

c 0  0  0

a 0  1  0

b 1  0  1

a 0  1  0

连续i子串的特点就是如果str1[i]和str2[j]是属于某公共子串的最后一个字符，那么一定有str1[i]=str2[j] && str1[i-1] = str2[j-1]，从矩阵中直观的看，就是由“1”构成的“斜线”代表的序列都是公共子串，那么最长公共子串肯定就是斜线“1”最长的那个串。

那么现在问题就可以转化了，只要构造出如上的一个矩阵，用n^2的时间就可以得到矩阵，然后再到矩阵中去寻找最长的那个“1”构成的斜线就可以了！那么，现在又有了新的问题？如何快速的找到那个“1”构成的最长斜线呢？

采用DP的思想，如果str1[i] = str2[j]，那么此处的包含str1[i] 和 str2[j]公共子串的长度必然是包含str1[i-1]和str2[j-1]的公共子串的长度加1，那么现在我们可以重新定义lcs(i,j)，即是lcs(i,j) = lcs(i-1,j-1) + 1，反之，lcs(i,j) = 0。那么上面的矩阵就变成了如下的样子：

--b  a  b

c 0  0  0

a 0  1  0

b 1  0  2

a 0  2  0

现在问题又变简单了，只需要花n^2的时间构造这样一个矩阵，再花n^2的时间去找到矩阵中最大的那个值，对应的就是最长公共子串的长度，而最大值对应的位置对应的字符，就是最长公共子串的最末字符。

 

 

 

最长公共子序列自己写的java代码如下：

import java.util.Scanner;


public class LCS {
 public static void main(String[] args) {
  Scanner input = new Scanner(System.in);
  String s1 = input.next();
  String s2 = input.next();
  char[] x = new char[s1.length()];
  char[] y = new char[s2.length()];
  int[][] a = new int[s1.length()+1][s2.length()+1];
  int[][] b = new int[s1.length()+1][s2.length()+1];
  
  for(int i=0;i<s1.length();i++) {
   x[i] = s1.charAt(i);
  }
  for(int j=0;j<s2.length();j++) {
   y[j] = s2.charAt(j);
  }
  LcsLength(x,y,a,b);
  printLcs(x.length,y.length,x,b);
  
 }

 private static void printLcs(int i, int j, char[] x, int[][] b) {
  //反向回溯搜索
  if(i==0 && j==0) return;
  if(b[i][j]==1){
   printLcs(i-1,j-1,x,b);
   System.out.print(x[i-1]);
  }
  else if(b[i][j]==2) {
   printLcs(i-1,j,x,b);
  }
  else 
   printLcs(i,j-1,x,b);
  
 }

 

 最长公共子串的java代码：

 

import java.util.Scanner;


public class LCS {
	private static void LcsLength(char[] x, char[] y, int[][] a) {
		//用二维矩阵记录连续相同元素的个数，若相等a[i][j]=a[i][j]+1，否则赋0
		for(int i=0;i<=x.length-1;i++) {
			for(int j=0;j<=y.length-1;j++) {
				if(i==0 || j==0) {
					if(x[i]==y[j]) {
						a[i][j]=1;
					}
					else 
						a[i][j]=0;
				}
				else {
					if(x[i]==y[j]) {
						a[i][j]=a[i-1][j-1]+1;
					}
					else 
						a[i][j]=0;
				}
			}
		}
	}
	
	private static void printLcs(int i, int j, char[] x, int[][] a) {
		//斜线搜索
		int maxLength = 0; 
		int xIndex=i,yIndex=j;
		for(int m=i; m>=0; m--) { //求最大的a[m][n],maxLength就代表是最长的子序列
			for(int n=j; n>=0; n--) {
				if(a[m][n]>maxLength) {
					maxLength = a[m][n];
					xIndex = m;
					yIndex = n;
				}
			}
		}
		System.out.println("最长公共子串长度："+maxLength);
		int n=yIndex-maxLength+1;
		for(int m = xIndex-maxLength+1;m<=xIndex;m++) {
				System.out.print(x[m]);
				n++;	
		}
	}

	
	public static void main(String[] args) {
		Scanner input = new Scanner(System.in);
		String s1 = input.next();
		String s2 = input.next();
		char[] x = new char[s1.length()];
		char[] y = new char[s2.length()];
		int[][] a = new int[s1.length()][s2.length()];
		
		for(int i=0;i<s1.length();i++) {
			x[i] = s1.charAt(i);
		}
		for(int j=0;j<s2.length();j++) {
			y[j] = s2.charAt(j);
		}
		LcsLength(x,y,a);
		printLcs(x.length-1,y.length-1,x,a);	
	}

}