算法分析-DP(Dynamic Programming)之LCS(Long Common Subsequence)

最新推荐文章于 2022-08-30 09:17:39 发布
最新推荐文章于 2022-08-30 09:17:39 发布
阅读量404 收藏 4
点赞数 3
分类专栏： 算法 文章标签： 算法 动态规划 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46957647/article/details/121257128
版权

文章目录

前言

鸡爸爸对自家的三儿子产生了怀疑，因为他没有继承自己优良的基因，于是鸡爸爸带着他去找了鉴定中心，小鸡内心忐忑不安，因为爸爸看上去很生气，对他没有了以往的温柔。此时一切只能交给鉴定结果了…
在这里插入图片描述

在这里插入图片描述
经过缴费抽样后，有了以下结果，S1是鸡爸爸的基因序列，S2是小鸡的基因序列。

S1=ACCGGTCGAGTGCGCGGAAGCCGGCCGAA... S2=GTCGTTCGGAATGCCGTTGCTCTGTAAA...

肉眼还是无法给出结果，于是，鉴定人员拿出来 神秘的“计算机”。求出如下的最长公共子序列，经过计算，相似度居然高达99.99%。听到医生的鉴定结果，小鸡留下了争气的眼泪，鸡爸爸也逐渐平息了怒火，最后鸡爸爸牵着小鸡开心的走上了回家的路…

S3=GTCGTCGGAAGCCGGCCGAA...

在测序之前，问题是生物学问题
测序之后，问题变成了计算机问题

那最长公共子序列我们应该怎么来算呢!

↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓

一、问题描述

★ 一个给定序列的子序列是在该序列中删去若干元素后得到的序列
★给定2个序列X和Y，当另一序列Z既是X的子序列又是Y的子序列时，称Z是序列X和Y的公共子序列
★ 公共子序列中长度最长的公共子序列叫做最长公共子序列
★ 最长公共子序列(Longest Common Subsequence, LCS)问题可 以叙述为：

  • 给定2个序列X={x1，…，xm}和Y={y1，…，yn}，要求找出X和Y的一个最长公共子序列

例：
X = {A, B, C, B, D, A, B}
Y = {B, D, C, A, B, A}
LCS = ﹛B D A B﹜ 还有﹛ B C A B ﹜和﹛B C B A﹜

二、问题解决

1.穷举搜索法

❆ 假设x的长度为m，y的长度为y，对于x的每一个子序列，检查他是否是y的子序列，即为两者的公共子序列

❆ 选出所有结果的最长子序列

❆ x={1，2，…，m} 共有 2m个公共子序列

❆ 穷举法的时间复杂度为： T(n)=(2m*n)

2.动态规划法(填表法)

使用动态规划必须满足两个条件，最优子结构与重叠子问题。
最优子结构：

  • 两个序列的最长公共子序列包含了两个序列的前缀的最长公共子序列
  • 最长公共子序列包含最优子结构性质

由最长公共子序列问题的最优子结构性质可知，要找出X={x1，…，xm}和Y={y1，…，yn}的一个最长公共子序列，可按以下方式递归地进行：

  • 当Xm = Yn时，找出X(m-1)和Y(n-1)的最长公共子序列，然后在其尾部加上Xm(=Yn)即可得X和Y的一个最长公共子序列
  • Xm ≠ Yn，即找出X(m-1)和Y的最长公共子序列或者X和Y(n-1)的最长公共子序列，较长者即为两个序列的LCS

综上有了如下的递归公式：
在这里插入图片描述

重叠子问题：
分析上面的递归公式，不难看出问题存在重叠子问题，并且递归高度为X序列的长度和Y序列的长度之和m+n
在这里插入图片描述

三、算法实现

1.递归实现

根据上面的递归方程，得到如下的递归代码：

	private static int LCS(char[] x, char[] y, int i, int j) {
		if(i>=0&&j>=0) {//递归结束条件		
			if(x[i]==y[j]) {
				c[i][j] = LCS(x,y,i-1,j-1)+1;
			}else {
				c[i][j] = Math.max(LCS(x,y,i-1,j),LCS(x,y,i,j-1));
			}
			return c[i][j];
		}else {
			return 0;
		}
	}

}

如上面递归树分析得到的一样，递归中同一问题求解了多次，我们可以用一个二维数组保存我们求解过的问题，事实上我们的 c数组已经保存下来了，我们直接使用就可以了

由此可得下面的备忘录法：

2.备忘录法

	private static int LCS(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] = LCS(x,y,i-1,j-1)+1;
				}else {
					c[i][j] = Math.max(LCS(x,y,i-1,j),LCS(x,y,i,j-1));
				}		
			}
				return c[i][j];
		}else {
			return 0;
		}
	}

}

备忘录的时间复杂度为 O(m×n)；比暴力求解O(n×2m)好很多了，n和m分别为Y序列和X序列的长度。指数增长还是过于恐怖了。

3.动态规划法

填一张表(二维数组)，然后输出c数组最右下位置的值，即最大公共子序列的长度。

X = {A, B, C, B, D, A, B}

Y = {B, D, C, A, B, A}
在这里插入图片描述
首先初始化数组c
for(int i=0;i<=m;i++) c[i][0]=0;
for(int j=0;j<=n;j++) c[0][j]=0;
从1，1位置开始比较：

  • 如果X序列的第一个位置和Y序列的第一个位置相等，c[1][1] = c[0][0]+1;
  • 如果不相等，那么c[1][1]等于他上边或左边最大的值，可以看到c[1][1]上面的c[0][1]和左边的c[1][0]都等于0，所以c[1][1]=0;

不相等时为什么要取左边或上边最大的值，看c[3][4,]，此时X[3]不等于Y[4] 如果我们取c[3][4]等于上面的1，意思是X1 = {A, B, C, B} ，Y1 = {B, D} ，Y1加上{C} 后其最大公共子序列长度为1，显然X2 = {A, B, C}，Y2 = {B, D，C}有最大公共子序列长度为2。
所以应该取左边或上边最大的值。

填表的过程：

	private static void lcsLength(char[] x, char[] y,int[][] b) {
		int m = x.length;
		int n = y.length;
		//c = new int[m+1][n+1];
		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和b数组的i，0和0，j位置为0，从1，1位置开始用来记录，x从0到m-1，y从0到n-1
					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 {
					c[i][j] = c[i][j-1];
					b[i][j] = 3;
				}
	
			}
		}
	}

输出最长子序列：

	private static void printLcs(int i, int j ,char[] x) {
		if(i==0||j==0) {
			return ;
		}else if(b[i][j]==1) {
			printLcs(i-1,j-1,x);
			System.out.print(x[i-1]);
		}else if(b[i][j]==2) {
			printLcs(i-1,j,x);
		}else {
			printLcs(i,j-1,x);
		}
	}

在这里插入图片描述

综合：

import java.util.Scanner;

public class Oj1_DP_LCS {
	static int[][] c;
	static int[][] b;
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		while(sc.hasNext()) {
			char[] X = sc.nextLine().toCharArray();
			char[] Y = sc.nextLine().toCharArray();
			int m=X.length,n=Y.length;
			c = new int[m+1][n+1];
			b = new int[m+1][n+1];
			lcsLength(X,Y,b);
			System.out.println(c[m][n]);
			printLcs(m,n,X);
		}
	}
	//输出LCS
	private static void printLcs(int i, int j ,char[] x) {
		if(i==0||j==0) {
			return ;
		}else if(b[i][j]==1) {
			printLCS(i-1,j-1,x);
			System.out.print(x[i-1]);
		}else if(b[i][j]==2) {
			printLCS(i-1,j,x);
		}else {
			printLCS(i,j-1,x);
		}
		
	}
	//填表
	private static void lcsLength(char[] x, char[] y,int[][] b) {
		int m = x.length;
		int n = y.length;
		//c = new int[m+1][n+1];
		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和b数组的i，0和0，j位置为0，从1，1位置开始用来记录，x从0到m-1，y从0到n-1
					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 {
					c[i][j] = c[i][j-1];
					b[i][j] = 3;
				}
	
			}
		}
	}

}

四、优化

1.不使用b数组

因为c[ i ][ j ]由 c[ i-1 ][ j-1 ], c[ i-1 ][ j ],c[ i ][ j-1 ]三个数确定，在输出LCS时同样可以用这三个数在O(1)的时间里来确定c[i][j]由三个数的哪一个数得来，从而节省θ(m*n)的空间。

	private static void printLCS(int i, int j ,char[] x) {
		if(i==0||j==0) {
			return ;
		}else if(c[i][j]==c[i-1][j-1]+1) {
			printLCS(i-1,j-1,x);
			System.out.print(x[i-1]);
		}else if(c[i][j]==c[i-1][j]) {
			printLCS(i-1,j,x);
		}else {
			printLCS(i,j-1,x);
		}
		
	}

2.滚动数组

如果只想得到最长公共子序列的长度，那么算法的空间需求将大大减少，在计算c[i][j]时，我们只用到了c的第i行和第i-1行。用这两行就可以算出最长公共子序列。最后输出c[0][n]即结果。

参考代码：

	private static void lcsLength(char[] x, char[] y,int[][] b) {
		int m = x.length;
		int n = y.length;
		//c = new int[m+1][n+1];
		//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[1][j] = c[0][j-1]+1;
				}
				else if(c[0][j]>c[1][j-1]) {
					c[1][j] = c[0][j];
				}else {
					c[1][j] = c[1][j-1];	
				}

			}
		
		for(int j=1;j<=n;j++) {
				
				c[0][j] = c[1][j];
				c[1][j] = 0;
			}
		}

	}
城了个南
关注
  • 3
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
lcs.rar_Common Subsequence_LCS_lcs matlab_subsequence
09-23
LCS Longest (maximum) common subsequence
LIS和LCS算法分析
weixin_34224941的博客
07-27 196
LIS（最长上升子序列） 常规的解法就是动态规划。 mx[ j ]表示长度为j的上升子序列最小的值a[i]; dp[ i ]表示前i个数的最长上升子序列长度多少。 1 for(int i=1;i<n;i++) 2 { 3 int j; 4 for( j=len;j>0;j--) 5 { 6 i...
算法分析与实践_LCS算法
weixin_43653737的博客
04-25 211
一、问题 二、解析 三、设计 四、分析 O(mn) 五、源码 https://github.com/weiwenqi666/homework
golang--Dynamic programming --LCS
freedbg的博客
01-23 298
package main import ( "fmt" ) func main() { //DP 是一种设计技术 fmt.Println("Dynamic programming LCS") str1 := "ABCBDAB" str2 := "BDCABA" fmt.Println(str1[1] == 'B') l1 := len(str1) l2 := len(str
算法分析与设计（实验九LCS）
qq_45506707的博客
04-28 158
#include <iostream> #include <cstring> #include <vector> #include <algorithm> #include <cstdlib> using namespace std; int lcs_len(string s1, string s2){ int len1 = s1...
（算法设计技巧与分析）LCS
lonely_Quan的专栏
03-10 660
#include #include using namespace std; void LCS(int **,char[],int,char[],int); void LCS_print(int **,stack&,int ,char c[],int); int main() { char c1[]="xyxxzxyzxy"; char c2[]="zxzyyzxxyxxz"; int **
LCSLength.rar_LCSlength_vc数据库_算法LCS－LENGTH
09-19
用动态规划算法求两个序列的最长公共子序列。
基于预测的手势识别算法分析-研究论文
06-10
手势识别是计算机理解人类肢体语言的一种方式。... 在我的调查中，我发现当应用 DTW（动态时间包装）算法时，他们达到了 75% 的准确率，而 LCS（最长公共子序列）方法在识别手势方面达到了 85% 的准确率。
Java算法之最长公共子序列问题(LCS)实例分析
08-28
主要介绍了Java算法之最长公共子序列问题(LCS),结合实例形式分析了最长公共子序列的原理及问题解决方法,需要的朋友可以参考下
leetcode2sumc-Dynamic_Programming:与dynamic_programming相关的程序
06-30
dp 相关的背包方法 2.Leetcode Problem of Partition Equall Subset Sum :- 将子集分成 2 个相等的部分 3.Subset Sum Count :- 计算给定总和 k 的数组中的子集数 细绳 1.最长公共子序列(lcs.py) 2.最长公共子序列...
算法作业九——LCS算法
qq_43403657的博客
04-27 169
1.问题 LCS（最长公共子序列） 一个数列 S，如果分别是两个或多个已知数列的子序列，且是所有符合此条件序列中最长的，则S 称为已知序列的最长公共子序列。 2.解析 注意最长公共子串（Longest CommonSubstring）和最长公共子序列（LongestCommon Subsequence, LCS）的区别：子串（Substring）是串的一个连续的部分，子序列（Subsequence...
Dynamic Programming longest common subsequence(LCS) 动态规划之最长公共子序列
午夜飞行
12-06 976
问题描述 在生物学应用中，经常要比较两个DNA的相似度，一个DNA可看做是一个串。一种衡量方法是，我们说这两个DNA相似可以看做S1是S2的子串（字符串匹配问题）。第二种方法是找出第三个串S3，S3中的每一个元素都出现在S1和S2中，这就是一个求最长公共子序列的应用。 例如： S1 =ABCD ; S2 = BECD; 那么LCS S3= BCD； 解决一群LCS的问题属于NP-h
Dynamic Programming 学习笔记(二) LIS vs LCS
那时那刻
01-05 578
LIS (Longest Increasing Subsequence) 最长上升子序列。 题目：给出一个序列a1,a2,a3,a4,a5,a6,a7….an,求它的一个子序列（设为s1,s2,…sn），使得这个子序列满足这样的性质，s1 LCS (Longest Common Subsequence) 最长公共子序列。 题目：一个数列 S，如果其分别是两个或多个已知数列的子序列，且是最长的
Java:实现查找两个序列之间的最长公共子序列LCS算法（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
08-30 253
Java:实现查找两个序列之间的最长公共子序列LCS算法（附完整源码）
【算法】LCS算法以及其JAVA的实现
ES丶舞弄的博客
12-13 2320
LCS问题是动态规划的经典问题，同时也算作入门问题吧。其目的是要求出两个串的最长公共子串。例如如下两个串： 串1：ABCBDAB 串2：BDCABA 那么，它们的最长公共子序列是BCBA。注意，最长公共子序列不是最长的公共串，最长的公共串在leetcode里面好像有过这么一道题，用暴力求解的方法也能在很短的时间内算出来，不会耗费太长的时间。但是最长的公共子序列不是连续的，要找出来，就需要将串...
LCS（最长公共子串和最长公共子序列）java实现
weixin_42735784的博客
03-11 1561
LCS最长公共子串 动态规划法： 定义字符串str1的索引为i, 第二个字符串str2的索引为j 定义dp[i][j] 为**str1.substring(0, i+1)和str2.substring(0,j+1)**的公共子串的长度 定义状态转移方程 原理：如果2个字符串的最后一个不相等，它们的LCS=空串， 若相等，2个都往前推一位，该情况的子串+这一位就是现在的子串 ja...
最长公共子序列 | 记忆化递归 | 动态规划 | LCS Longest Common Subsequences | C/C++实现
qq_40998706的博客
01-28 436
问题描述 最长公共子序列问题(Longest Common Subsequence problem, LCS)是求两个给定序列X={x1, x2, …, xm}与Y={y1, y2, …, yn}最长公共子序列的问题。 如果序列Z同时为X和Y的子序列，那么Z就称为X与Y的公共子序列。例，设X={a, b, c, b, d, a, b};Y={b, d, c, a, b, a}，那么序列{b, c,...
UVA111 History Grading【LCS+DP+记忆化递归】
海岛Blog
04-03 534
Many problems in Computer Science involve maximizing some measure according to constraints.     Consider a history exam in which students are asked to put several historical events...
LCS最长公共子序列 java 递归+DP
wl20222022的博客
05-07 658
在两个字符串中，有些字符会一样，可以形成的子序列也有可能相等，因此，长度最长的相等子序列便是两者间的最长公共字序列，其长度可以使用动态规划来求。 以s1={1,3,4,5,6,7,7,8},s2={3,5,7,4,8,6,7,8,2}为例。 创建 DP数组dp[][]; import java.util.ArrayList; /** * @author wl * @Data 202...
longest common subsequence
最新发布
08-03
最长公共子序列（Longest Common Subsequence，简称LCS）是指在给定多个序列中，找到最长的一个子序列，该子序列同时出现在这些序列中，并且其他元素的相对顺序保持一致。 举个例子，假设有两个序列A和B，A为[1, 2,...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值