算法--- 动态规划之最长公共子序列问题

最新推荐文章于 2024-10-21 08:17:44 发布
最新推荐文章于 2024-10-21 08:17:44 发布
阅读量3.2k 收藏 24
点赞数 5
分类专栏： 技巧 文章标签： 算法 动态规划 最长子序列问题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38346954/article/details/79994988
版权

一.概念梳理

（1）子序列： 一个序列A ＝ a1,a2,……an,中任意删除若干项，剩余的序列叫做A的一个子序列。也可以认为是从序列A按原顺序保留任意若干项得到的序列。

例如：

对序列 1,3,5,4,2,6,8,7来说，序列3,4,8,7 是它的一个子序列。
对于一个长度为n的序列，它一共有2^n 个子序列，有(2^n – 1)个非空子序列。

请注意：子序列不是子集，它和原始序列的元素顺序是相关的。

（2）公共子序列 ： 顾名思义，如果序列C既是序列A的子序列，同时也是序列B的子序列，则称它为序列A和序列B的公共子序列。

例如：

对序列 1,3,5,4,2,6,8,7和序列 1,4,8,6,7,5 来说

序列1,8,7是它们的一个公共子序列。

请注意： 空序列是任何两个序列的公共子序列。
例如： 序列1,2,3和序列4,5,6的公共子序列只有空序列。


（3）最长公共子序列
A和B的公共子序列中长度最长的（包含元素最多的）叫做A和B的公共子序列。
仍然用序列1,3,5,4,2,6,8,7和序列1,4,8,6,7,5


请大家用集合的观点来理解这些概念，子序列、公共子序列以及最长公共子序列都不唯一，所以我们通常说一个最长公共子序列，但显然最长公共子序列的长度是一定的。

最长公共子序列问题就是求序列A= a1,a2,……an, 和B = b1,b2,……bm,的一个最长公共子序列。

因为最长公共子序列不唯一，让我们把问题简化，如何求出两个序列的最长公共子序列长度呢？

你首先能想到的恐怕是暴力枚举？那我们先来看看：序列A有 2^n 个子序列，序列B有 2^m 个子序列，如果任意两个子序列一一比较，比较的子序列高达 2^(n+m) 对，这还没有算具体比较的复杂度。

或许你说，只有长度相同的子序列才会真正进行比较。那么忽略空序列，我们来看看：对于A长度为1的子序列有C(n,1)个，长度为2的子序列有C(n,2)个，……长度为n的子序列有C(n,n)个。对于B也可以做类似分析，即使只对序列A和序列B长度相同的子序列做比较，那么总的比较次数高达：

C(n,1)*C(m,1)*1 + C(n,2) * C(m,2) * 2+ …+C(n,p) * C(m,p)*p
其中p = min(m, n)。

 

试试使用动态规划算法！

二.动态规划

     求解LCS问题，不能使用暴力搜索方法，一个长度为N的序列拥有的2的次方个子序列，它的时间复杂度是指数阶，因此解决LCS问题，需要借助动态规划的思想。
     动态规划算法通常用于求解具有某种最优性质的问题。在这类问题中，可能会有许多可行解。每一个解都对应于一个值，我们希望找到具有最优值的解。动态规划算法与分治法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。若用分治法来解这类问题，则分解得到的子问题数目太多，有些子问题被重复计算了很多次。如果我们能够保存已解决的子问题的答案，而在需要时再找出已求得的答案，这样就可以避免大量的重复计算，节省时间。我们可以用一个表来记录所有已解的子问题的答案。不管该子问题以后是否被用到，只要它被计算过，就将其结果填入表中。这就是动态规划法的基本思路。

三.特征分析

1.最长公共子序列的结构

设序列X={Y1,Y2,...Yn}和Y={Y1,Y2,...Ym}的最长公共子序列为 Z= {Z1,Z2,...Zk},则

（1）若Xm=Yn, 则Zk = Xm = Yn ,且Zk-1 是 Xm-1 和Y n-1 的最长公共子序列。

（2）若Xm!=Yn ,且Zk!=Xm,则Z是Xm-1和Y的最长公共子序列。

（3）若Xm!=Yn ,且Zk!=Yn,则Z是X和Yn-1的最长公共子序列。

LCS问题具有最优子结构 

2.子问题的递归结构

    由最长公共子序列问题的最优子结构性质可知，要找出X={X1,X2,...Xn}和Y={Y1,Y2,...Ym}的最长公共子序列，可按以下方式递归进行。当Xm= Yn 时，找出Xm-1和Yn-1的最长公共子序列，然后在其尾部加上 Xm(=Yn)  即可得X和Y的最长公共子序列，当 Xm !=Yn时，必须解两个子问题，既找出 Xm 和 Yn 的一个最长公共子序列及 X 和 Yn-1的一个最长公共子序列。这两个公共子序列中较长者即为X和Y的最长公共子序列。

    由此递归结构容易看到，最长公共子序列问题具有子问题重叠性质。例如，在计算X和Y的最长公共子序列时，可能要计算X和Yn-1及Xm-1的最长公共子序列。而这两个子问题都包括一个公共子问题，既计算Xm-1和Yn-1的最长公共子序列。

首先建立子问题最优值的递归关系。用C[ i ][ j ] 记录序列Xi和 Yj的最长公共子序列的长度。其中，X={X1,X2,...Xn}和Y={Y1,Y2,...Ym}。当i=0 或 j=0 时，空序列是 Xi 和 Yj 的最长公共子序列。故此C[ i ][ j ] = 0. 其他情况下，由最优子结构性质可建立递归关系如下：


四.计算最优值

    直接利用递归容易写出计算C[ i ][ j ]的递归算法， 但其计算时间是随输入长度指数增长的，由于在所考虑的子问题空间中，共有0（m,n）个不同的 子问题，因此，用动态规划算法自顶向上计算最优值能提高算法效率。

    计算最长刚刚子序列长度的动态规划算法LCSlength以序列X = {X1,X2,...Xn}和Y = { Y1,Y2,... Ym} 作为输入，输入两个数组C 和B，其中C [ I ][ J ]储存Xi 和 Yj 的最长公共子序列的长度， B [ i ][ j ]记录 C [ i ][ j ]的值是由哪个子问题解得到的，这在构造最长公共子序列时要用到。问题的最优值， 既 X 和 Y 的最长公共子序列的长度记录 C [ M ] [ N  ]中。

void LCSlength(int m , int n, char *x, char *y ,int c[][MAX],int b[][MAX])
{
	int i,j;
	for(i=0;i<=m;i++)c[i][0]=0;
	for(j=0;j<=n;j++)c[0][j]=0;
	for(i =1;i<=m;i++)
	{
	for( j=1;j<=n;j++)
	{
		if(x[i-1]==y[j-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;
			 }
		}
		
	}
}

 五.构造最长公共子序列

    由算法LCSlength计算得到的数组 B 可以用于快速构造序列 X = {X1,X2,...Xn}和Y = { Y1,Y2,... Ym} 的最长公共子序列。首先从      b [ m ] [ n ] 开始，依次在数组b中搜索。当在 b[ i ][ j ] = 1 时，表示Xi 和 Yj 的最长公共子序列是由 X i-1 和 Y j-1 的最长公共子序列在尾部加上 Xi 所得到的子序列。当 b [ i ] [ j ]  = 2 时，表示Xi 和 Y j  的最长公共子序列与 Xi-1 和Y i的最长公共子序列相同。

当 b [ i ] [ j ]  = 3 时，表示Xi 和 Y i  的最长公共子序列与 Xi-1 和Y j-1 的最长公共子序列相同。

    下面的算法LCS实现依据 b的内容打印出Xi 和Yj 的最长公共子序列。通过算法调用LCS 便可打印出序列X和Y的最长公共子序列。

void LCS(int i,int j , char *x,int b[][MAX])
{
	if(i==0||j==0)
		 return ;
	if(b[i][j]==1)
	{
		LCS(i-1,j-1,x,b);
		cout<<x[i-1]<<" ";
	}
	else if (b[i][j]==2)
	{
	LCS(i-1,j,x,b);
	}
		else
		 LCS(i,j-1,x,b); 
	
}
        可见我们在计算长度LCS的时候只要多记录一些信息，就可以利用这些信息恢复出一个最长公共子序列来。就好比我们在迷宫里走路，走到每个位置的时候记录下我们时从哪个方向来的，就可以从终点回到起点一样。
    

代码一：


#include<iostream>
#include<cstring>
#define MAX 50
using namespace std;
//1  x[m]==y[n]==z[k] z[k-1]是X[m-1] Y[n-1]的最长公共子序列
//2  x[m]!=y[n]  且z[k]！=x[m] Z是x[m-1]与Y的最长公共子序列	
//3  x[m]!=y[n]  且z[k]!= y[n] Z是X和y[n-1]的最长公共子序列 
void LCSlength(int m , int n, char *x, char *y ,int c[][MAX],int b[][MAX])
{
	int i,j;
	for(i=0;i<=m;i++)c[i][0]=0;
	for(j=0;j<=n;j++)c[0][j]=0;
	for(i =1;i<=m;i++)
	{
	for( j=1;j<=n;j++)
	{
		if(x[i-1]==y[j-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;
			 }
		}
		
	}
}
void LCS(int i,int j , char *x,int b[][MAX])
{
	if(i==0||j==0)
		 return ;
	if(b[i][j]==1)
	{
		LCS(i-1,j-1,x,b);
		cout<<x[i-1]<<" ";
	}
	else if (b[i][j]==2)
	{
	LCS(i-1,j,x,b);
	}
		else
		 LCS(i,j-1,x,b); 
	
}
int main()
{
	 char x[MAX]={"ABCBDAB"};
	 char y[MAX]={"BDCABA"} ; 
	 int b[MAX][MAX],c[MAX][MAX] ;
	 int m,n;
	 m=strlen(x);
	 n=strlen(y);
	 LCSlength(m,n,x,y,c,b);
	 LCS(m,n,x,b) ;
	return 0;
}

代码二：


#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int LCSLength(char* str1, char* str2, int **b)
{
	int i,j,length1,length2,len;
	length1 = strlen(str1);
	length2 = strlen(str2);

	//双指针的方法申请动态二维数组
	int **c = new int*[length1+1]; //共有length1+1行
	for(i = 0; i < length1+1; i++)
		c[i] = new int[length2+1];//共有length2+1列

	for(i = 0; i < length1+1; i++)
		c[i][0]=0;        //第0列都初始化为0
	for(j = 0; j < length2+1; j++)
		c[0][j]=0;        //第0行都初始化为0

	for(i = 1; i < length1+1; i++)
	{
		for(j = 1; j < length2+1; j++)
		{
			if(str1[i-1]==str2[j-1])//由于c[][]的0行0列没有使用，c[][]的第i行元素对应str1的第i-1个元素
			{
				c[i][j]=c[i-1][j-1]+1;
				b[i][j]=0;          //输出公共子串时的搜索方向
			}
			else if(c[i-1][j]>c[i][j-1])
			{
				c[i][j]=c[i-1][j];
				b[i][j]=1;
			}
			else
			{
				c[i][j]=c[i][j-1];
				b[i][j]=-1;
			}
		}
	}
	/*
	for(i= 0; i < length1+1; i++)
	{
	for(j = 0; j < length2+1; j++)
	printf("%d ",c[i][j]);
	printf("\n");
	}
	*/
	len=c[length1][length2];
	for(i = 0; i < length1+1; i++)    //释放动态申请的二维数组
		delete[] c[i];
	delete[] c;
	return len;
}
void PrintLCS(int **b, char *str1, int i, int j)
{
	if(i==0 || j==0)
		return ;
	if(b[i][j]==0)
	{
		PrintLCS(b, str1, i-1, j-1);//从后面开始递归，所以要先递归到子串的前面，然后从前往后开始输出子串
		printf("%c",str1[i-1]);//c[][]的第i行元素对应str1的第i-1个元素
	}
	else if(b[i][j]==1)
		PrintLCS(b, str1, i-1, j);
	else
		PrintLCS(b, str1, i, j-1);
}

int main(void)
{
	char str1[100],str2[100];
	int i,length1,length2,len;
	printf("请输入第一个字符串：");
	gets(str1);
	printf("请输入第二个字符串：");
	gets(str2);
	length1 = strlen(str1);
	length2 = strlen(str2);
	//双指针的方法申请动态二维数组
	int **b = new int*[length1+1];
	for(i= 0; i < length1+1; i++)
		b[i] = new int[length2+1];
	len=LCSLength(str1,str2,b);
	printf("最长公共子序列的长度为：%d\n",len);
	printf("最长公共子序列为：");
	PrintLCS(b,str1,length1,length2);
	printf("\n");
	for(i = 0; i < length1+1; i++)//释放动态申请的二维数组
		delete[] b[i];
	delete[] b;
	system("pause");
	return 0;
}

代码三：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int max1(int m,int n)
{
	if(m>n)
		return m;
	else
		return n;
}
int max2(int x,int y,int z,int k,int m,int n)
{
	int max=-1;
	if(x>max)
		max=x;
	if(y>max)
		max=y;
	if(z>max)
		max=z;
	if(k>max)
		max=k;
	if(m>max)
		max=m;
	if(n>max)
		max=n;
	return max;
}
int LCSLength(char* str1, char* str2, char* str3) //求得三个字符串的最大公共子序列长度并输出公共子序列
{
	int i,j,k,length1,length2,length3,len;
	length1 = strlen(str1);
	length2 = strlen(str2);
	length3 = strlen(str3);

	//申请动态三维数组
	int ***c = new int**[length1+1];      //共有length1+1行
	for(i = 0; i < length1+1; i++)
	{
		c[i] = new int*[length2+1];      //共有length2+1列
		for(j = 0; j<length2+1; j++)
			c[i][j] = new int[length3+1];
	}

	for(i = 0; i < length1+1; i++)
	{
		for(j = 0; j < length2+1; j++)
			c[i][j][0]=0;
	}
	for(i = 0; i < length2+1; i++)
	{
		for(j = 0; j < length3+1; j++)
			c[0][i][j]=0;
	}
	for(i = 0; i < length1+1; i++)
	{
		for(j = 0; j < length3+1; j++)
			c[i][0][j]=0;
	}

	for(i = 1; i < length1+1; i++)
	{
		for(j = 1; j < length2+1; j++)
		{
			for(k = 1; k < length3+1; k++)
			{
				if(str1[i-1]==str2[j-1] && str2[j-1]==str3[k-1])
					c[i][j][k]=c[i-1][j-1][k-1]+1;
				else if(str1[i-1]==str2[j-1] && str1[i-1]!=str3[k-1])
					c[i][j][k]=max1(c[i][j][k-1],c[i-1][j-1][k]);
				else if(str1[i-1]==str3[k-1] && str1[i-1]!=str2[j-1])
					c[i][j][k]=max1(c[i][j-1][k],c[i-1][j][k-1]);
				else if(str2[j-1]==str3[k-1] && str1[i-1]!=str2[j-1])
					c[i][j][k]=max1(c[i-1][j][k],c[i][j-1][k-1]);
				else
				{
					c[i][j][k]=max2(c[i-1][j][k],c[i][j-1][k],c[i][j][k-1],c[i-1][j-1][k],c[i-1][j][k-1],c[i][j-1][k-1]);
				}
			}
		}
	}
	len=c[length1][length2][length3];
	for(i = 1; i < length1+1; i++) //释放动态申请的三维数组
	{
		for(j = 1; j < length2+1; j++)
			delete[] c[i][j];
		delete[] c[i];
	}
	delete[] c;
	return len;
}

int main(void)
{
	char str1[100],str2[100],str3[100];
	int len;

	printf("请输入第一个字符串：");
	gets(str1);
	printf("请输入第二个字符串：");
	gets(str2);
	printf("请输入第三个字符串：");
	gets(str3);
	len=LCSLength(str1,str2,str3);
	printf("最长公共子序列的长度为：%d\n",len);
	system("pause");
	return 0;
}

代码一是让你在函数内定义好两个序列，然后输出最长公共子序列和长度。
代码二是让你输入两个序列，然后输出最长公共子序列和长度。
代码二是让你输入两个序列，然后输出最长公共子序列和长度。
代码三是让你输入三个序列，然后输出最长公共子序列的长度。



很过分的人
关注
专栏目录
动态规划法如何来解决最长公共子序列问题
JobinXin的博客
07-15 1714
1、最长公共子序列问题。设有两个字符序列X和Y，它们的元素分别存放在数组x[m+1]和y[n+1]中，x[0]和y[0]不放元素。公共子序列存放在数组z[]中。完成如下函数。 2、int CommonOrder(int m,int n,char x[],char y[],char z[])函数功能是返回两字符序列的最长公共子序列长度值。并且公共子序列存放在数组z[]中。 3、写主函数main()，实现输入数组x[]和y[]，调用 CommonOrder函数，并输出公共子序列。 （1）解题思路：引进一个二维数
动态规划 最长公共子序列 过程图解
热门推荐
hrn1216的博客
05-29 28万+
1.基本概念       首先需要科普一下，最长公共子序列（longest common sequence）和最长公共子串（longest common substring）不是一回事儿。什么是子序列呢？即一个给定的序列的子序列，就是将给定序列中零个或多个元素去掉之后得到的结果。什么是子串呢？给定串中任意个连续的字符组成的子序列称为该串的子串。给一个图再解释一下：        如
通俗理解动态规划：由浅入深DP并解决LCS问题(23年修订版)
结构之法 算法之道
12-31 11万+
动态规划算法解LCS问题作者 July 二零一零年十二月三十一日本文参考：微软面试100题系列V0.1版第19、56题、算法导论、维基百科。第一部分、什么是动态规划算法 ok，咱们先来了解下什么是动态规划算法。 动态规划一般也只能应用于有最优子结构的问题。最优子结构的意思是局部最优解能决定全局最优解(对有些问题这个要求并不能完全满足，故有时需要引入一定的近似)。简单地说，问题能
动态规划详解：最长公共子序列问题的高效解法
最新发布
qq_22841387的博客
10-21 1644
我们可以定义一个二维数组dp，其中dp[i][j]表示text1[0:i]和text2[0:j]的最长公共子序列的长度。动态规划是解决最长公共子序列问题的最优解法，时间复杂度为O(m * n)，空间复杂度也是O(m * n)。通过二维数组存储子问题的解，可以避免大量的重复计算。**递归法（带备忘录）**也是一种可行的方案，它通过递归来逐步求解子问题，使用备忘录存储中间结果，从而避免重复计算，时间复杂度同样为O(m * n)。
动态规划----------最长公共子序列问题
qq_46016011的博客
01-18 2461
记录算法学习-----动态规划实现最长公共子序列问题 一、问题描述 子序列：将给定的序列中的零个或者多个元素（如字符）去掉后的结果（表示不连续的一串字符）。 问题：给定两个序列X={x1, x2, … xm}和Y={y1, y2, …, yn}找出X和Y的最长公共子序列。 例子： 输入：text1 = “abcde”, text2 = “ace” 输出：3 解释：最长公共子序列是 “ace” ，它的长度为 3 。 题目源于力扣 二、解题思路 方法一：暴力枚举法，对序列x的所有子序列依次判断是否为y的子序列，
算法套路十五——动态规划求解最长公共子序列LCS
Pistachiout的学习博客
05-11 2528
给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0。一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。
动态规划算法求最长公共子序列
l0760over的博客
04-19 1018
动态规划是一种解决复杂问题的算法技巧，常用于求解最优化问题。它的主要思想是将问题划分为一系列子问题，通过寻找子问题之间的某种递推关系来求解。通常，动态规划算法的解决过程涉及以下几个步骤：确定状态：把原问题转化为子问题，找出子问题的状态。状态的选择通常是具有以下两个特点的：（1）只与当前子问题相关（2）包含了当前子问题所需要的所有信息。确定状态转移方程：确定子问题之间的递推关系，即根据子问题的状态，推出每个子问题的最优解。状态转移方程是一个递推式，它基于已解出的子问题来解决当前子问题。
算法设计与分析实验报告-动态规划寻找最长公共子序列.doc
12-11
总的来说，动态规划在解决最长公共子序列问题时展现了其强大之处，通过优化算法设计，避免了指数级的时间复杂度，实现了线性时间复杂度的高效解决方案。实验报告不仅提升了对动态规划的理解，还锻炼了编程实现和问题...
算法设计-最长公共子序列动态规划算法.doc
05-08
动态规划算法是解决最长公共子序列问题的有效方法。该算法通过建立一个二维数组来存储子问题的解，从而避免了重复计算。 知识点一：最长公共子序列问题 最长公共子序列问题是指给定两个序列 X 和 Y，找出 X 和 Y ...
第四章 基本的算法策略-3-动态规划-最长公共子序列.pptx
06-02
这部分内容主要涉及了算法设计中的一个重要概念——动态规划，并特别聚焦于如何利用动态规划解决最长公共子序列（LCS，Longest Common Subsequence）问题。下面我们将从以下几个方面进行详细阐述： ### 一、子序列...
基于Java+动态规划算法解决最长公共子序列问题.zip
05-10
最长公共子序列（Longest Common Subsequence，LCS）问题是一个经典的计算机科学问题，主要涉及字符串处理和算法设计。在两个或多个字符串中找到一个最长的子序列，这个子序列不必连续，但必须保持原顺序。例如，...
动态规划算法--解最长公共子序列问题
proplume的博客
12-23 1万+
如今最好，没有来日方长！ 一、简述动态规划算法1.动态规划算法简介（1）背景动态规划(英语：Dynamic programming，简称：DP)是一种算法设计技术，是运筹学的一个分支，是求解决策过程(Decision process)最优化的数学方法。值得注意的是，这个技术名字中的“programming”是计划和规划的意思，不是计算机领域中的编程。它有着有趣的历史。 它由20世纪50年代初美国一
使用动态规划解决最长公共子序列问题
heart_love的博客
03-04 7957
一、定义： 给定两个序列X和Y，如果Z既是X的子序列也是Y的子序列，那么我们称Z是X和Y的公共子序列。例如：X={a,b,c,e,d,g,f}，Y={b,e,f,g},那么Z={b}、Z={b,e}、Z={b,e,f}都是X和Y的公共子序列，其中Z={b，e，f}是X和Y的最长公共子序列。求解X和Y的最长公共子序列就是LCS问题。最长公共子序列不唯一，但是其长度是唯一的。 二、定理： 令X=
动态规划法解最长公共子序列问题
douyh的专栏
01-23 2451
问题描述 给定两个字符串，求解这两个字符串的最长公共子序列（Longest Common Sequence）。 输入序列“ ABCDGH”和“ AEDFHR”的LCS为长度3的“ ADH”。 输入序列“ AGGTAB”和“ GXTXAYB”的LCS为长度4的“ GTAB”。 最佳子结构： 假设输入序列分别为长度为m和n的X [0…m-1]和Y [0…n-1]。并令L（X [0…m-1]，Y [0…n-1]）为两个序列X和Y的LCS的长度。以下是L（X [0 … m-1]，Y [0…n-1]）。 如果两个序列
最长公共子序列
jaub的技术专栏
01-08 805
下面的文字来自于网络，最后给出引用位置。     一、动态规划算法    事实上，最长公共子序列问题也有最优子结构性质。    记：    Xi = 即X序列的前i个字符（1    Yj = 即Y序列的前j个字符（1        假定Z = 是LCS（X,Y)中的一个。    ·若xm = yn（最后一个字符相同），则不难用反
动态规划算法之最长公共子序列问题
淡然坊
12-25 1万+
问题描述 　　给定两个字符串，寻找这两个字串之间的最长公共子序列。 输入格式 　　输入两行，分别包含一个字符串，仅含有小写字母。 输出格式 　　最长公共子序列的长度。 样例输入 abcdgh aedfhb 样例输出 3 样例说明 　　最长公共子序列为a，d，h。 数据规模和约定 　　字串长度1~1000。 分析：求最长公共子序列，用动态规划~只需建立一个长宽为两个字符
最长公共子序列问题（动态规划）
m0_52124992的博客
03-28 7901
最长公共子序列问题 动态规划
算法：动态规划——最长公共子序列
Sauron7i的博客
04-23 6523
文章目录一、动态规划概念1. 动态规划步骤最长公共子序列问题题目示例分析代码（递归）查表打印最长公共子序列 一、动态规划概念 动态规划算法与分治法类似，其基本思想也是将待求解问题分解成若干个子问题，先求解子问题，然后从这些子问题的解得到原问题的解。 与分治法不同的是，适合于用动态规划法求解的问题，经分解得到的子问题往往不是互相独立的。若用分治法解这类问题，则分解得到的子问题数目太多，以至于最后解决原问题需要耗费指数时间。 然而，不同子问题的数目常常只有多项式量级。在用分治法求解时，有些子问题被重复计算了许多
动态规划求解最长公共子序列
weixin_33979203的博客
02-25 843
前言 推出一个新系列，《看图轻松理解数据结构和算法》，主要使用图片来描述常见的数据结构和算法，轻松阅读并理解掌握。本系列包括各种堆、各种队列、各种列表、各种树、各种图、各种排序等等几十篇的样子。 最长公共子序列 最长公共子序列，英文为Longest Common Subsequence，缩写LCS。一个序列，如果是某两个或多个已知序列的最长子序列，则称为最长公共子序列。 另外，要注意的是最长公共子...
Java实现动态规划求解最长公共子序列
资源摘要信息: "本文档提供了使用Java语言结合动态规划算法解决最长公共子序列（LCS）问题的详细实现方法。动态规划是一种在数学、管理科学、计算机科学、经济学和生物信息学等领域中，用来解决多阶段决策问题的方法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值