动态规划之最长公共子串

最新推荐文章于 2024-08-12 21:49:42 发布
最新推荐文章于 2024-08-12 21:49:42 发布
阅读量1.6w 收藏 19
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jianfpeng241241/article/details/51926420
版权

一 问题引入

在生物学中，经常需要比较两个不同生物的DNA，一个DNA串由由一串称为碱基的的分子组成，碱基有鸟嘌呤，腺嘌呤，胞嘧啶，胸腺嘧啶四中，我们用英文字母的首字母表示四种碱基，那么DNA就是在有限集{A,C,G,T}上的一个字符串。例如某种生物的DNA序列为：S1=ACCGGTCGAGTGCGCGGAAGCCGGCCGAA，S2=GTCGTTCGGAATGCCGTTGCTCTGTAAA，我们比较两个DNA串的原因就是希望确定他们的相似度，作为衡量两个物种相似度的标准。如果一个串是另外一个串的子串，那么它们就是相似的，但是这里彼此都不是彼此的子串。于是我们就有了新的衡量标准：寻找一个新串S3，使得S3中的元素都在S1，S2中出现过，且不要求连续，但是碱基在三个串中出现的顺序一定要相同。可以找到的S3的长度越长，表明两个物种越相似！

二 问题描述
给定两个字符串X[A,B,C,B,D,A,B]和Y[B,D,C,A,B,A],求X和Y的最长公共子序列LCS

三 思路

1 采用暴力破解法: 扫描X所有的可能子串, 取其中一个字符时候,存在 取或不取两种情况, 假设X字符串有M个字符,则子串个数为2的M次方,

假设Y有N个字符,将M中取出的子串与Y中进行对比,最后的时间复杂度为 N*2^M，  简直是龟速啊。。。

2 简化方案

 2.1 从题目描述中 X = [A,B,C,B,D,A,B] , Y[B,D,C,A,B,A] ,目测最大公共子串为 BDAB , BCAB ,最长为4.

 2.2 假设从一开始就知道X,Y的最大长度为4 ，那么只要关心X为4的子串与Y进行对比,这样效率就提高了.

 2.3 进一步假设X字符串转为char数组后坐标为{0,1,2,3,4.....M} , 同理Y为{0,1,2,3...N}

   假设  i  <= M , j <= N  , c[i][j] =LCS( X,Y)  . // i ,j 为一个int整数  , c[i][j]为 X的char数组{0,1,2,3....i} 和Y的char数组{0,1,2,3...j} 最大公共子串的长度

 // LCS 为 longestcommon subsequence (  最长公共子串 ) 的缩写 .

   那么对于X{0,1,2,3.....M} , Y{0,1,2,3....N}的最大公共子串长度为

   c[i][j] + LCS(X1,Y1)

 其中 X1 的坐标{ i+1,i+2,.....M } ,Y1坐标为{j+1,j+2....N}.

  求最大公共子串长度总结 :  一部分长度( 假设已知)  + 另外一部长度( 需要求的 ) 

四 公式

最大公共子串公式1

  if (X[i] == Y[j] )   c[i][j] = c[i-1][j-1] + 1  

   证明 :

假设X , Y (见图1) , 在X {0，1，2，...i} , Y {0,1,2,3...j} 中最长公共子串长度为 k ,那么 在X{0,1,2,3...,i-1} ,Y{0,1,2,3,...,j-1}(见图2)中最长公共子串长度为k-1


图1


图2


反证法 : X{0,1,2,3...,i-1} ,Y{0,1,2,3,...,j-1}中最长公共子串长度为k-1不成立, 即存在一个w ( w > k-1 ) ,那么 如上图2 , 当 X[i] == Y[j] 时候, 即在X {0，1，2，...i} , Y {0,1,2,3...j} 中, 最大公共子串长度为 w+1 > (  k-1 ) +1 > k ,这与原命题矛盾,所以不存在这样一个w值.

即    if (X[i] == Y[j] )   c[i][j] = c[i-1][j-1] + 1  

最大公共子串公式2

  if (X[i] != Y[j] )  c[i][j] = max( c[i][j-1] , c[i-1][j] )  // max (a ,b) 返回a,b两个数中最大的一个 ,如果相等,则返回a

理解 : c[i][j] 对应图3 , c[i-1][j] 对应图4, c[i][j-1]对应图5, 那么最大公共子串长度一定是c[i-1][j] 和c[i][j-1]中的一个 ,用上面反证法即可证明.

图3



图4


图5




五 递归调用图

假设X{0,1,2,3..M},Y{0,1,2,3,...N} 中M =7 , N = 6,那么它的调用图如下.


从这幅图中看出

1 树的高度为 M+N = 7+6 = 15

2 时间复杂度 2^(M+N) = 2^13 (比暴力破解时间N*2^M=6*2^7还要多很多, 假设不采用备忘录法和没有重复情况下, 动态规划时间复杂度比暴力破解复杂度高很多,但 经测试在M=29，N=28,时候 ,暴力破解法时间为 300万次 ,动态规划调用1000多次,后面有代码,可自行测试)

3 有少量重复调用,比如红框1和红框2，都是递归6,5这种情况

六 动态规划的特征

1 最优子结构 (包含问题最优解),如 最大公共子串公式2 .

2 重复子问题,如 五 递归调用图

七 自顶向下+备忘录法 java代码

伪代码  

LCS(x,y,i,j)
  if(x[i]==y[j]) c[i][j] = LCS(x,y,i-1,j-1)+1
  else c[i][j] = max(LCS(x,y,i-1,j) , LCS(x,y,i,j-1))
return c[i][j]

java代码

LCS.java

public class LCS {
	private  static int[][] c;
	private static int counter;
	/**
	 * 判断是否为空
	 * */
	private static boolean isNullOrBlank(String source){
		if(source==null||"".equals(source.replace(" ", ""))) return true;
		return false;
	}
	
	/**
	 * 得到最长公共子串
	 * */
	public static int  getLcs(String xStr,String yStr){
		if( isNullOrBlank(xStr) || isNullOrBlank(yStr) ) return 0;
		char[] xChar = xStr.toCharArray();
		char[] yChar = yStr.toCharArray();
		c = new int[xChar.length][yChar.length];
		int lcsMaxNumber = getLcsMaxNumber(xChar,yChar,xChar.length-1,yChar.length-1);
		return lcsMaxNumber;
	}
	
	private static int max(int x,int y){
		if(x>y) return x;
		return y;
	}
	
//	/**
//	 * 不采用备忘录法
//	 * 得到LCS最长公共子串的长度
//	 * */
//	private  static int getLcsMaxNumber(char[] x,char[] y,int i,int j){
//		counter++;
//		   if(i>=0&&j>=0){ // c[i][j]初始化为0，当不为0时,表示已经遍历过
//			    if(x[i]==y[j]){
//					    c[i][j] = getLcsMaxNumber(x,y,i-1,j-1) + 1;
//					  }else{
//						c[i][j] = max(getLcsMaxNumber(x,y,i-1,j),getLcsMaxNumber(x,y,i,j-1));
//				 } 
//			  System.out.println("counter = "+counter+"  c["+i+"]["+j+"] = " + c[i][j]);
//			 return c[i][j];
//		   }
//		
//		  return 0;
//	}
	

	/**
	 * 备忘录法
	 * 得到LCS最长公共子串的长度
	 * */
	private  static int getLcsMaxNumber(char[] x,char[] y,int i,int j){
		counter++;
	   if(i>=0&&j>=0){ 
		  if(c[i][j]==0){
			  if(x[i]==y[j]){ // c[i][j]初始化为0，当不为0时,表示已经遍历过
				    c[i][j] = getLcsMaxNumber(x,y,i-1,j-1) + 1;
				  }else{
					c[i][j] = max(getLcsMaxNumber(x,y,i-1,j),getLcsMaxNumber(x,y,i,j-1));
			 } 
		  }
		   System.out.println("counter = "+counter+"  c["+i+"]["+j+"] = " + c[i][j]);
		 return c[i][j];
	   }
	
	  return 0;
	
	}
	
	public static void main(String[] args) {
//		String x = "ABCBDAB";
//		String y = "BDCABA";
		String x = "ACCGGTCGAGTGCGCGGAAGCCGGCCGAA";
		String y = "GTCGTTCGGAATGCCGTTGCTCTGTAAA";
		int number = LCS.getLcs(x, y);
		System.out.println(number);
	}

}
对于前面提到的DNA的输出最大公共子串长度为20

八 回溯法求最大公共子串

回溯法原理

假设 X = "ABCBDAB";  Y= "BDCABA",它们生成一副下面的图


 ↖   ↑   ←符号解释
 ↖ 输出该y{j}的值，并且向左斜角走一步
  ↑ 表示向上走一步 
  ←向左走一步
那么当 i = 7 , j = 6时候, 输出元素为 ABCB ,把该字符串反向后,为BCBA( BCBA即为X和Y的最大公共子串 )

最大公共完整java代码 （代码中 b+c 为对应上面回溯原理中的图） 
public class LCS2 {
	private  static int[][] c; //保存长度
	private  static char[][] b; //保存特殊符号 ↖   ↑   ←
	
	/**
	 * 判断是否为空
	 * */
	private static boolean isNullOrBlank(String source){
		if(source==null||"".equals(source.replace(" ", ""))) return true;
		return false;
	}
	/**
	 * 得到最长公共子串
	 * */
	public static String getLCS(String x,String y){
		//判断x,y是否为空
		if( isNullOrBlank(x) || isNullOrBlank(y) ) return null;
		//初始化变量
		int m = x.length();
		int n = y.length();
		b = new char[m][n];
		c = new int[m][n];
		char[] xChar = x.toCharArray();
		char[] yChar = y.toCharArray();
		//调用获取最大公共子串长度方法
		getLcsMaxNumber(xChar,yChar,xChar.length-1,yChar.length-1);
		//回溯法得到最长公共子串
		StringBuffer sb = new StringBuffer();
		PRINT_LCS(sb,xChar,yChar,m-1,n-1);
	  return sb.toString();
		
	}
	
	private static int max(int x,int y){
		if(x>y) return x;
		return y;
	}
	
	/**
	 * 备忘录法
	 * 得到LCS最长公共子串的长度
	 * */
	private  static int getLcsMaxNumber(char[] x,char[] y,int i,int j){
		if(i>=0&&j>=0){ 
		  if(c[i][j]==0){
			  if(x[i]==y[j]){ // c[i][j]初始化为0，当不为0时,表示已经遍历过
				    c[i][j] = getLcsMaxNumber(x,y,i-1,j-1) + 1;
				    b[i][j] = '↖';
				  }else{
					int i_1 = getLcsMaxNumber(x,y,i-1,j);
					int j_1 = getLcsMaxNumber(x,y,i,j-1);
					if(i_1>j_1){
						 c[i][j] = i_1;
						 b[i][j] = '↑';
					}else{
						c[i][j] = j_1;
						b[i][j] = '←';
					}
			 } 
		  }
		 return c[i][j];
	   }
	
	  return 0;
	
	}
	
	
	//回溯法得到最长公共子串
	private static void PRINT_LCS(StringBuffer sb,char[] x,char[] y,int i,int j){
		if(i==0 || j==0 ){
			if(b[i][j]=='↖'){
				sb.append(x[i]);
			}
			return ;
		}
		if(b[i][j]=='↖'){
			PRINT_LCS(sb,x,y,i-1,j-1);
			sb.append(x[i]);
		}else if(b[i][j]=='↑'){
			PRINT_LCS(sb,x,y,i-1,j);
		}else if(b[i][j]=='←'){
			PRINT_LCS(sb,x,y,i,j-1);
		}
	}

	public static void main(String[] args) {
//		String x = "ABCBDAB";
//		String y = "BDCABA";
		
		String x = "ACCGGTCGAGTGCGCGGAAGCCGGCCGAA";
		String y = "GTCGTTCGGAATGCCGTTGCTCTGTAAA";
		String lcs = LCS2.getLCS(x, y);
		System.out.println("最大公共子串为  = " + lcs);

	}

}
问题引入中  DNA序列为：S1= ACCGGTCGAGTGCGCGGAAGCCGGCCGAA ，S2= GTCGTTCGGAATGCCGTTGCTCTGTAAA的,
由该程序求得,最大公共子串为  = GTCGTCGGAAGCCGGCCGAA


清风明月coder
关注
专栏目录
sdut 1008 最大公共字串
ACM2272902662的专栏
10-23 2911
最大公共子串 Time Limit: 1000MS Memory limit: 32768K 题目描述 从一个给定的串中删去（不一定连续地删去）0个或0个以上的字符，剩下地字符按原来顺序组成的串。例如：“ ”，“a”，“xb”，“aaa”，“bbb”，“xabb”，“xaaabbb”都是串“xaaabbb”的子串。（例子中的串不包含引号。） 编程求N个非空串的最长公共子串
动态规划—最长公共子串
sanmi8276的博客
01-27 730
问题描述：有两个字符串str和str2，求出两个字符串中最长公共子串长度。str=acbcbcef，str2=abcbced，则str和str2的最长公共子串为bcbce，最长公共子串长度为5。 算法思路： 把两个字符串分别以行和列组成一个二维矩阵。 比较二维矩阵中每个点对应行列字符中否相等，相等的话值设置为1，否则设置为0。 通过查找出值为1的最长对角线就能找到最长公共子串。 针对于上面的两个字符串我们可以得到的二维矩阵如下： 从上图可以看到，str1和str2共有5个公共子串，但最长的公共
LeetCode1143. 最长公共子序列 动态规划详解
最新发布
Lentr0py的博客
08-12 587
通过动态规划的思想，我们能够高效地解决最长公共子序列问题。通过合理定义dp数组的含义，状态转移方程，以及对初始状态的处理，可以解决类似的子序列问题。
最长公共子串(动态规划)
weixin_59551524的博客
05-04 6259
查找两个字符串a,b中的最长公共子串_牛客题霸_牛客网 1.找a 和 b 的最长公共子串实际上是在a的子串和b的子串中找最长公共子串 ins[i][j]实际上记录的就是 以a的第i个字符和以b的第j个字符结尾的子串中存在的最长公共子串的长度 接下来我们举个例子: a: abcabcde b: abcd ins[1][1] = 'a' 'a' --> 'a' 1 ins[2][2] = 'ab' 'ab' --> 'ab' 2 ins[3][3] = 'abc' 'ab...
动态规划——最长公共子串
monlyy的博客
05-09 397
最长公共子串问题是指在两个或多个字符串之间找到最长的连续子串。子序列可以不连续，子串必须是连续的。解决该问题的方法有暴力枚举法以及动态规划dp。将两串字符串中的字符一一进行比较，得出最长子串的起点和长度后，进行输出。dp[i][j]代表的x的前i个字符串与y的前j个字符串的最长公共子串，如果两个字符相等，则dp[i][j]=dp[i-1][j-1]+1;如果不相等，就说明不满足最长公共子串，自然dp[i][j]=0.
动态规划——最长公共子序列和最长公共子串之Python实现
10-22
用Python实现动态规划中最长公共子序列和最长公共子串问题！
java实现求两个字符串最长公共子串的方法
09-03
在编程领域，求解两个字符串的最长公共子串是一个经典问题，主要应用于文本处理、比较和搜索算法。这里我们将深入探讨如何使用Java实现这一方法，同时结合华为在线判题平台（OJ）的要求来编写代码。 首先，我们需要...
PHP实现求两个字符串最长公共子串的方法示例
10-18
在编程领域，最长公共子串（Longest Common Substring，LCS）问题是一个经典的问题，它寻找两个或多个字符串中的最长连续子序列，这个子序列同时存在于所有字符串中。在这个问题中，我们专注于PHP如何解决两个字符串...
C语言求两个字符串的最长公共子串
09-03
在C语言中，求两个字符串的最长公共子串是一个经典的问题，它涉及到字符串处理和算法。最长公共子串是指在两个或多个字符串中都存在的、且长度最长的连续字符序列。这个问题在文本处理、数据比较和生物信息学等领域...
动态规划：最长公共子串 LCS
12-02
动态规划：最长公共子串 LCS 动态规划：最长公共子串 LCS
动态规划算法之： 最长公共子串
daa20的专栏
09-20 594
最长公共子串与最长公共子序列区别： 找两个字符串的最长公共子串，这个子串要求在原字符串中是连续的。而最长公共子序列则并不要求连续。 其实这是一个序贯决策问题，可以用动态规划来求解。我们采用一个二维矩阵来记录中间的结果。这个二维矩阵怎么构造呢？直接举个例子吧：”bab”和”caba”(当然我们现在一眼就可以看出来最长公共子串是”ba”或”ab”)　　 b　　a　　bc　　0　　0　　0a　　0
最长公共子串（动态规划）
Liquor___的博客
03-26 520
最长公共子串（动态规划） 题目描述 给出两个数组或字符串，求其最长公共子串 给定串中任意个连续的字符组成的子序列称为该串的子串。 这是一个动态规划的题目。对于可用动态规划求解的问题，一般有两个特征：①最优子结构；②重叠子问题 先要明确怎么获取子问题。给定m，n长度的数组，其子问题是一步步把数组长度缩小找其最长公共子串。从最小各自长度为1，套用双层循环一层层增加两个数组长度。 设A=“a0，a1，…...
动态规划——最长公共子串，没有比这更通俗易懂的了
热门推荐
青春无问西东 岁月自成芳华
12-09 2万+
动态规划——最长公共子串，也是高频的考点，需要重点掌握
最长公共子串 动态规划
cdtdt的博客
01-04 2566
最长公共子串 动态规划，详细注释
动态规划 - 最长公共子序列 - 最长公共子串 - 最长不重复子串 - 最长递增子序列 - 最长回文子串
星星之火
06-05 1973
源自：http://blog.csdn.net/chuan6099/article/details/8952978 动态规划法 经常会遇到复杂问题不能简单地分解成几个子问题，而会分解出一系列的子问题。简单地采用把大问题分解成子问题，并综合子问题的解导出大问题的解的方法，问题求解耗时会按问题规模呈幂级数增加。 为了节约重复求相同子问题的时间，引入一个数组，不管它们是否对最终解有
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值