动态规划 最长公共子序列

公共子序列：即序列X和序列Y共有的序列，可以不是连续序列，但子序列存在顺序排列

例如：X : 3 2 1 5 7 9 5 4                Y ：6 3 1 4 7 4 2

则序列X和序列Y最长公共子序列为 3 1 7 4（有时可能不唯一）

第一个想到的是直接暴力破解，对每个X的子序列进行穷举，检查每个子序列是否是Y的子序列，但如果X有m个元素，X的子序列有2^m个，此时时间复杂度为指数阶，肯定不可行。于是用了动态规划构造最优解的方法来做这种题。

子问题之间的依赖关系：

设X={x1,x2,x3,……xm} 和 Y={y1,y2,y3,……yn}，Z={z1,z2,z3,……zk}为X和Y的LCS(最长公共子序列)

1. xm=yn  =>  zk=xm=yn,且Zk-1是Xm-1和Yn-1的LCS;

2. xm!=yn   zk!=xm  =>  Zk是Xm-1和Yn的LCS;

3. xm!=yn   zk!=ym  =>  Zk是Xm和Yn-1的LCS;

所以 最长公共子序列递归式：

具体的思路可参考动态规划 最长公共子序列 过程图解，这篇博客挺详细的。（其实我也不怎么懂φ(>ω<*)）。

 

代码

#include<iostream>
#include<cstring>
using namespace std;

#define N 101

int c[N][N];//记录最长公共子列的长度 
int b[N][N];// 记录最长公共子列的长度的来源 
char s1[N],s2[N];
int len1,len2;

//最长子列求解函数 
void LCS()
{
	int i,j;
	for(i=1;i<=len1;i++)
	{
		for(j=1;j<=len2;j++)
		{
			if(s1[i-1]==s2[j-1])
			{
				//如果当前字符相等，则公共子序列长度为该字符前的最长子序列+1 
				c[i][j]=c[i-1][j-1]+1;
				b[i][j]=1;
			}
			else
			{
				//两者找最大 
				if(c[i][j-1]>=c[i-1][j])
				{
					c[i][j]=c[i][j-1];
					b[i][j]=2;
				}
				else
				{
					c[i][j]=c[i-1][j];
					b[i][j]=3;
				}
			}
		}
	}


	
} 

void print(int i,int j)
{
	if(!i || !j)
		return;
	if(b[i][j]==1)
	{
		print(i-1,j-1);
		cout<<s1[i-1];
	}
	else
	{
		if(b[i][j]==2)
			print(i,j-1);
		else
			print(i-1,j);		
	}	
}

int main()
{
	int i,j;
	cout<<"输入第一个字符串s1 :"<<endl;
	cin>>s1;
	cout<<"输入第一个字符串s2 :"<<endl;
	cin>>s2;
	len1=strlen(s1);
	len2=strlen(s2);
	
	for(i=0;i<=len1;i++)
	    c[i][0]=0;//初始化第一列 
	for(j=0;j<=len2;j++)
		c[0][j]=0;//初始化第一行 
	LCS();
	cout<<"s1和s2的最长子序列长度为："<<c[len1][len2]<<endl;
	cout<<"s1和s2的最长公共子序列为：";
	print(len1,len2);
	return 0;
}