最长公共子字序列和最长公共子字符串

最长公共子串（Longest CommonSubstring）和最长公共子序列（LongestCommon Subsequence, LCS）的区别：子串（Substring）是串的一个连续的部分，子序列（Subsequence）则是从不改变序列的顺序，而从序列中去掉任意的元素而获得的新序列；更简略地说，前者（子串）的字符的位置必须连续，后者（子序列LCS）则不必。比如字符串acdfg同akdfc的最长公共子串为df，而他们的最长公共子序列是adf。LCS可以使用动态规划法解决。

一、最长公共子序列

   考虑最长公共子序列问题如何分解成子问题，设A=“a0，a1，…，am-1”，B=“b0，b1，…，bn-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”的一个最长公共子序列。

解决方法：

引进一个二维数组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]。

      问题的递归式写成：

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

 

代码如下：

public static int getCommonSubsequence(String A,String B){
	if(A==null||A.length()==0){
		return 0;
	}
	if(B==null||B.length()==0){
		return 0;
	}
		
	int lenA=A.length();
	int lenB=B.length();
		
	int[][] c=new int[lenA+1][lenB+1];//注意这个地方增加了一行和一列
	int maxLen=0;
		
	for(int i=0;i<lenA+1;i++){
		c[i][0]=0;  //第0列都初始化为0  
	}
	//j=0时c[i][j]=0
	for(int j=0;j<lenB+1;j++){
		c[0][j]=0;//第0行都初始化为0  
	}
	//
	for(int i=1;i<lenA+1;i++){
		for(int j=1;j<lenB+1;j++){
			//对应第一个性质 
			if(A.charAt(i-1)==B.charAt(j-1)){//由于c[][]的0行0列没有使用，c[][]的第i行元素对应str1的第i-1个元素  
				c[i][j]=c[i-1][j-1]+1;
			}
			else{
				c[i][j]=Math.max(c[i-1][j], c[i][j-1]);
			}
		}
	}
	for(int i=1;i<lenA+1;i++){
		for(int j=1;j<lenB+1;j++){
			if(maxLen<c[i][j]){
				maxLen=c[i][j];
			}
		}
	}
	return maxLen;
		
}

二、最长公共子字符串

解法一、动态规划的思想

动态转移方程为：

（1） i=0时，如果xi == yj，c[i][j]=1;如果xi ! = yj,  那么c[i][j] = 0

（2）j=0时，  如果xi== yj，c[i][j]=1;如果xi ! = yj,  那么c[i][j] = 0

（3） i>=1&&j>=1时，如果xi == yj， 则 c[i][j] = c[i-1][j-1]+1； 如果xi ! = yj,  那么c[i][j] = 0

比如字符串"acaccbabb"和字符串"acbac"可以得到这样的C[i][j]，如下所示：

  a c a c c b a b b
a 1 0 1 0 0 0 1 0 0 
c 0 2 0 2 1 0 0 0 0 
a 0 0 0 0 0 2 0 1 1 
c 1 0 1 0 0 0 3 0 0 
c 0 2 0 2 1 0 0 0 0 

代码如下：

public  int getCommonSubString(String a,String b){
	if(a==null||a.length()==0||b==null||b.length()==0){
		return 0;
	}
		
	int lenA=a.length();//字符串a的长度
	int lenB=b.length();//字符串b的长度
		
	int[][] c=new int[lenA][lenB];
	int maxLen=1;
	//第（1）种情况
	for(int i=0;i<lenA;i++){
		if(a.charAt(i)==b.charAt(0)){
			c[i][0]=1;
		}
		else
			c[i][0]=0;
	}
		
	//第（2）种情况
	for(int j=0;j<lenB;j++){
		if(a.charAt(0)==b.charAt(j)){
			c[0][j]=1;
				
		}
		else
			c[0][j]=0;
	}
		
	//第（3）种情况
	for(int i=1;i<lenA;i++){
		for(int j=1;j<lenB;j++){
			if(a.charAt(i)==b.charAt(j)){
				c[i][j]=c[i-1][j-1]+1;
			}
			else
				c[i][j]=0;
		}
	}
	//找出从c[][]数组中的最大值，即为最长公共子字符串的长度
	for(int i=0;i<lenA;i++){
		for(int j=0;j<lenB;j++){
			if(c[i][j]>maxLen){
				maxLen=c[i][j];
			}
		}
	}
		
	return maxLen;
}

解法二（来源于：http://blog.csdn.net/hackbuteer1/article/details/6686931）

将字符串s1和s2分别写在两把直尺上面(我依然用s1，s2来表示这两把直尺)，然后将s1固定，s2的头部和s1的尾部对齐，然后逐渐移动直尺s2，比较重叠部分的字符串中的公共子串的长度，直到直尺s2移动到s1的头部。在这个过程中求得的最大长度就是s1、s2最大子串的长度。

     下图是求解过程的图示（下图有点错误，应该是将s2从右往左移动），蓝色部分表示重叠的字符串，红色的部分表示重叠部分相同的子串

      其中s1="shaohui"，s2="ahui"，最后求得的结果为3

我实现的代码如下：

public static  int getCommonSubString(String a,String b){
	if(a==null||a.length()==0||b==null||b.length()==0){
		return 0;
	}
		
	int lenA=a.length();//字符串a的长度
	int lenB=b.length();//字符串b的长度
	int len=lenA+lenB;
	int max=0;
	for(int i=0;i<len;i++){
		int a_start=0;
		int b_start=0;
		if(i<lenA){
			a_start=lenA-i;
		}
		else{
			b_start=i-lenA;
		}
		int curMax=0;
		for(int j=0;(a_start+j<lenA)&&(b_start+j<lenB);j++){
			if(a.charAt(a_start+j)==b.charAt(b_start+j)){
				curMax++;
			}
			else{
				max=Math.max(curMax, max);
				curMax=0;
			}
				
		}
		max=Math.max(curMax, max);
			
	}
	return max;
}

参考：Java动态规划 实现最长公共子序列以及最长公共子字符串