【算法导论】动态规划之最长公共子序列

简介:         子序列:一个给定序列的子序列就是该给定序列去掉零个或者多个元素后的序列。例如:Z={B,C,D,B}是X={A,B,C,B,D,A,B}的一个子序列。

        子序列:一个给定序列的子序列就是该给定序列去掉零个或者多个元素后的序列。例如:Z={B,C,D,B}是X={A,B,C,B,D,A,B}的一个子序列。注意顺序不能改变

        公共子序列:既是序列X的子序列,又是序列Y的子序列。例如:X={A,B,C,B,D,A,B},Y={B,D,C,A,B,A},则序列{B,C,A}是X和Y的一个公共子序列,长度为4;序列{B,C,B,A}是X和Y的一个最长公共子序列(LCS),长度为4.

        当然,我们可以查用穷举法来解决问题,但是,对于一个长度为n的序列,其子序列为2^n,因此时间复杂度为指数形式,当n很大时,显然不合实际。由观察和推导可知,最长公共子序列具有最优子结构性质和重叠子问题性质。因此我们可以通过动态规划算法来找到最长公共子序列,其时间复杂度为O(mn+m+n)。(m,n分别为两个序列的元素个数)

        在下面的程序实现中,我假设两个序列为上面提到的X={A,B,C,B,D,A,B},Y={B,D,C,A,B,A},数组b对应于在计算c[i][j]时所选择的最优子问题的解,数组c[i][j]为Xi和Yj的一个LCS的长度,Xi为序列的前i个元素组成的序列,Yj为序列的前j个元素组成的序列.

具体程序如下:

#include<stdio.h>

void Lcs_Length(char *X,char *Y,int n1,int n2,int b[][7],int c[][7]);
void Print_Lcs(char *X,int b[][7],int i,int j);

void main()
{
	char X[]={'A','B','C','B','D','A','B'};
	char Y[]={'B','D','C','A','B','A'};
	int n1=sizeof(X)/sizeof(char);
	int n2=sizeof(Y)/sizeof(char);
	
	int b[8][7]={0};//b[i][j]对应于在计算c[i][j]时所选择的最优子问题的解
	int c[8][7]={0};//c[i][j]为Xi和Yi的一个LCS的长度
	
	Lcs_Length(X,Y,n1,n2,b,c);
	printf("最长公共子序列为:");
    Print_Lcs(X,b,n1,n2);
    printf("\n");
}
/*******************************************************************\
函数功能:计算最长公共子序列的长度,并将结果存储在数组c中
输入:    两个序列X、Y 待存储的数组b,c
输出:    无
\*******************************************************************/
void Lcs_Length(char *X,char *Y,int n1,int n2,int b[][7],int c[][7])
{
	
	for(int i=0;i<n1;i++)
		c[i][0]=0;
	for(int i=0;i<n2;i++)
		c[0][i]=0;
	for(int i=1;i<=n1;i++)
		for(int j=1;j<=n2;j++)
		{
			if(X[i-1]==Y[j-1])
			{
				c[i][j]=c[i-1][j-1]+1;
				b[i][j]=1;//b用于做标记,便于打印
			}
			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;
			}
		}
}


/*******************************************************************\
函数功能:打印最长公共子序列
输入:    原始序列X、已存储的数组b,i j表示是求X的前i个元素和Y的前j个元素的LCS
输出:    无
\*******************************************************************/
void Print_Lcs(char *X,int b[][7],int i,int j)
{
	if(i==0||j==0)
		return;
	if(b[i][j]==1)
	{
		Print_Lcs(X,b,i-1,j-1);//递归打印
		printf("%c ",X[i-1]);
	}
	else if(b[i][j]==2)
        Print_Lcs(X,b,i-1,j);
	else
		Print_Lcs(X,b,i,j-1);
	
}

上面程序得到的结果数组c和b如下图:

上表中的数字代表长度,例如c[7][6]=4代表序列X的前7个元素组成的序列和序列Y前6个元素组成的序列的最长公共子序列的长度为4.

在程序中为了方便起见,b数组用数字1,2,3分别代表↖,↑,←。


原文:http://blog.csdn.net/tengweitw/article/details/16950673

作者:nineheadedbird



目录
相关文章
|
2月前
|
存储 算法
深入了解动态规划算法
深入了解动态规划算法
58 1
|
2月前
|
算法 测试技术 C++
【动态规划算法】蓝桥杯填充问题(C/C++)
【动态规划算法】蓝桥杯填充问题(C/C++)
|
18天前
|
算法 Python
在Python编程中,分治法、贪心算法和动态规划是三种重要的算法。分治法通过将大问题分解为小问题,递归解决后合并结果
在Python编程中,分治法、贪心算法和动态规划是三种重要的算法。分治法通过将大问题分解为小问题,递归解决后合并结果;贪心算法在每一步选择局部最优解,追求全局最优;动态规划通过保存子问题的解,避免重复计算,确保全局最优。这三种算法各具特色,适用于不同类型的问题,合理选择能显著提升编程效率。
33 2
|
2月前
|
算法
动态规划算法学习三:0-1背包问题
这篇文章是关于0-1背包问题的动态规划算法详解,包括问题描述、解决步骤、最优子结构性质、状态表示和递推方程、算法设计与分析、计算最优值、算法实现以及对算法缺点的思考。
69 2
动态规划算法学习三:0-1背包问题
|
2月前
|
算法
动态规划算法学习四:最大上升子序列问题(LIS:Longest Increasing Subsequence)
这篇文章介绍了动态规划算法中解决最大上升子序列问题(LIS)的方法,包括问题的描述、动态规划的步骤、状态表示、递推方程、计算最优值以及优化方法,如非动态规划的二分法。
68 0
动态规划算法学习四:最大上升子序列问题(LIS:Longest Increasing Subsequence)
|
2月前
|
算法
动态规划算法学习二:最长公共子序列
这篇文章介绍了如何使用动态规划算法解决最长公共子序列(LCS)问题,包括问题描述、最优子结构性质、状态表示、状态递归方程、计算最优值的方法,以及具体的代码实现。
144 0
动态规划算法学习二:最长公共子序列
|
2月前
|
存储 人工智能 算法
【算法——动态规划】蓝桥ALGO-1007 印章(C/C++)
【算法——动态规划】蓝桥ALGO-1007 印章(C/C++)
【算法——动态规划】蓝桥ALGO-1007 印章(C/C++)
|
2月前
|
存储 算法
动态规划算法学习一:DP的重要知识点、矩阵连乘算法
这篇文章是关于动态规划算法中矩阵连乘问题的详解,包括问题描述、最优子结构、重叠子问题、递归方法、备忘录方法和动态规划算法设计的步骤。
110 0
|
2月前
|
算法 C++
【算法解题思想】动态规划+深度优先搜索(C/C++)
【算法解题思想】动态规划+深度优先搜索(C/C++)
|
4月前
|
机器学习/深度学习 算法 Java
算法设计(动态规划应用实验报告)实现基于贪婪技术思想的Prim算法、Dijkstra算法
这篇文章介绍了基于贪婪技术思想的Prim算法和Dijkstra算法,包括它们的伪代码描述、Java源代码实现、时间效率分析,并展示了算法的测试用例结果,使读者对贪婪技术及其应用有了更深入的理解。
算法设计(动态规划应用实验报告)实现基于贪婪技术思想的Prim算法、Dijkstra算法