程序设计思维与实践 Week10 作业B - LIS & LCS

题意

东东有两个序列A和B。
他想要知道序列A的LIS和序列AB的LCS的长度。
注意，LIS为严格递增的，即a1<a2<…<ak(ai<=1,000,000,000)。

Input

第一行两个数n，m（1<=n<=5,000,1<=m<=5,000）
第二行n个数，表示序列A
第三行m个数，表示序列B

Output

输出一行数据ans1和ans2，分别代表序列A的LIS和序列AB的LCS的长度

Example

Simple Input
5 5
1 3 2 5 4
2 4 3 1 5
Simple Output
3 2

最长上升子序列（LIS)总结及思想

暴力解法

对于这个问题，可以用最原始的办法来枚举各种情况，即对于每个元素有取或不取两种情况，然后判断序列是否为上升子序列。如果不是上升子序列，则更新最大长度。直到枚举完所有情况并得到最大长度，但是这种解法之下：如果有n个元素，时间复杂度将高达O(2^n)，这显然是不能承受的。

动态规划解法

令dp[i]表示以A[i]结尾的最长上升子序列长度，这样对于A[i]来说就有两种可能：

• 如果存在A[i]之前的元素A[j] (j < i），使得A[i]>A[j] 且 dp[i]< dp[j]+1（即把A[i]跟在以A[j]结尾的LIS后面时能比当前以A[i]结尾的LIS长度更长），那么就把A[i]跟在以A[j]结尾的LIS后面，形成一条更长的LIS（令dp[i]= dp[j]+1）；
• 如果A[i]之前的元素都比A[i]大，那么A[i]就只好自己形成一条LIS，但是长度为1，即这个子序列里面只有一个A[i]
  最后，以A[i]结尾的LIS长度就是两种情况中能形成的最大长度

例子

现有一个序列{1，5，-1，3}，其中元素分别记为A[1],A[2],A[3],A[4]。假设已经知道以A[1],A[2],A[3]为结尾的LIS 分别为{1}、{1，5}、{-1}，长度分别为1，2，1.那么如何知道以A[4]为结尾的LIS及其长度呢？由于必须以A[4]结尾，因此考虑分别把A[4]加到前面以A[1],A[2],A[3]结尾的LIS后面，发现：A[1]可加，A[2]不可加，A[3]可加，如此得到结果

状态转移方程：dp[i]=max(1,de[j]+1) (j=1,2,3,…,i-1&&A[i]>A[j])

上面的状态转移方程隐含了边界：dp[i]=1（1<=i<=n)。显然，dp[i]只与小于i的j有关，因此只要让i从小到大遍历即可求出整个dp数组。由于dp[i]表示的是以A[i]结尾的最长上升子序列长度，因此从整个dp数组中找到最大的那个才是要寻求的整个序列的LIS长度，自己鞥天复杂度为O（n^2)。

最长公共子序列（LCS）总结及思想

暴力解法

设序列A和B的长度分别为n和m，那么对两个序列中的每一个字符，分别有选和不选两种选择，而得到两个子序列后，比较两个子序列是否相同又需要O(max(m,n))，这样总复杂度会达到O（2^(m+n)*max(m,n)),无法承受数据大的情况；

动态规划解法(字符串举例）

令dp[i] [j]表示序列A（sadstory）的i号位和序列B（adminsorry）的j号位之前的LCS长度（下标从1开始），如：dp[4][5]表示“sads”和“adm in”的LCS长度。那么可根据A和B的现状，分为两种情况：

• 若A[i]==B[j],则序列A与B的LCS增加了1位，即有dp[i] [j]=dp[i-1] [j-1]+1；
• 若A[i]！=B[j]，则序列A的i号位与B的j号位之前的LCS无法延长，因此dp[i] [j]将会继承dp[i-1] [j]和dp[i] [j-1]中的较大值，即有dp[i] [j]=max （dp[i] [j-1]，dp[i-1] [j]）

状态转移方程：dp[i] [j]=dp[i-1] [j-1]+1 (A[i]==B[j]) ; dp[i] [j]=max （dp[i] [j-1]，dp[i-1] [j]） (A[i]！=B[j])

边界：dp[i] [0]=dp[0] [j]=0（0<=i<=n，0<=j<=m)
这样状态dp[i] [j]只与其之前的状态有关，由边界发出就可以得到整个dp数组，最终dp[n] [m]就是需要的答案，时间复杂度为O(nm）。

代码

#include <iostream>
#include <string>
#include <algorithm>
#include <cmath>
#include <cstring>
#include <stdio.h> 
using namespace std;
int A[5500],B[5500];
int n,m,ans1;
int dp[5500];  //dp[i]表示以a[i]结尾的最长上升序列长度 
int dp1[5500][5500];
void LIS() //最长上升子序列 
{
	memset(dp,0,sizeof(dp));
	ans1=-1;  //记录最大长度
	for(int i=1;i<=n;i++)   //按顺序计算dp[i]的值
	{
		dp[i]=1;  //边界初始条件（先假设每个元素自成一个子序列）
		for(int j=1;j<i;j++)
		{
			if(A[i]>A[j]&&(dp[j]+1>dp[i]))
				dp[i]=dp[j]+1;  //状态转移方程，更新dp[i] 
		}
		ans1=max(ans1,dp[i]);
	 } 
	cout<<ans1<<" ";
}

void LCS()  //最长公共子序列
{
	for(int i=0;i<=n;i++)
		dp1[i][0]=0;
	for(int i=0;i<=m;i++)
		dp1[0][i]=0;
	//状态转移方程
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			if(A[i]==B[j]) 
				dp1[i][j]=dp1[i-1][j-1]+1;
			else
				dp1[i][j]=max(dp1[i][j-1],dp1[i-1][j]);
		}
	 } 
	cout<<dp1[n][m]<<endl;
 } 

int main() 
{
	memset(A,0,sizeof(A));
	memset(B,0,sizeof(B));
	cin>>n>>m;
	for(int i=1;i<=n;i++)
		cin>>A[i];
	for(int i=1;i<=m;i++)
		cin>>B[i];
	LIS();
	LCS();
	return 0;
}