Week10：LIS与LCS

概念引入

LIS（最长上升子序列）：对于某个长为n的数列a0, a1, …, a(n-1)，其上升子序列指的是对于任意的i<j都满足ai<aj的子序列。最长上升子序列即为这些子序列里最长的那个。
LCS（最长公共子序列）：对于两个数列s1,s2，s1和s2的相同子序列，且该子序列的长度最长，即是LCS。

子序列是什么？如下图：

题目描述
给出两个序列A,B，要求得出A的LIS的长度与AB的LCS的长度。

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

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

输入样例

5 5
1 3 2 5 4
2 4 3 1 5

输出样例

3 2

解题思路
使用动态规划的思维
对于LIS：

• 构造数组dp[]用来储存序列A里每个数对应的最长上升子序列的长度，dp[]全部初始化为1。
• 遍历整个序列，对于每次遍历到的数A[i]，遍历在其之前的所有的数A[j]和其dp[j]：如果A[i]比A[j]要大（即满足上升）且dp[i]小于等于dp[j]，就用dp[j]+1更新dp[i]。

对于LCS：

• 构造二维数组f[][]用于储存结果，初始化f[1][0] = f[0][1] = f[0][0] = 0
• 对于每个f[i][j]，观察此时的A[i]与B[j]的值，如果相同，说明满足“公共”这个条件，那么f[i][j]即为f[i-1][j-1]+1
• 如果不相同，那么说明对于当前的A[i]或者B[j]是不能被同时选择的，那么此时的f[i][j]即为f[i][j-1]和f[i-1][j]里较大的那个。

代码：

#include <iostream>
#include <algorithm>
const int N = 5005;
using namespace std;

int A[N], B[N];
int n, m;

int dp[N];//LIS
int f[N][N];//LCS

int LIS()
{
	int ans = 0;
	dp[1] = 1;
	for (int i = 2; i <= n; i++)
	{
		dp[i] = 1;
		for (int j = i - 1; j > 0; j--)
		{
			if (A[i] > A[j] && dp[i] <= dp[j])
			{
				dp[i] = dp[j] + 1;
			}
		}
	}

	for (int i = 1; i <= n; i++)
	{
		if (dp[i] > ans)
		{
			ans = dp[i];
		}
	}

	return ans;
}

int LCS()
{
	f[1][0] = f[0][1] = f[0][0] = 0;

	for (int i = 1; i <= n; i++)
	{
		for (int j = 1; j <= m; j++)
		{
			if (A[i] == B[j])
			{
				f[i][j] = f[i - 1][j - 1] + 1;
			}
			else
			{
				f[i][j] = max(f[i - 1][j], f[i][j - 1]);
			}
		}
	}

	return f[n][m];
}

int main()
{
	cin >> n >> m;
	for (int i = 1; i <= n; i++)
		cin >> A[i];
	for (int i = 1; i <= m; i++)
		cin >> B[i];

	cout << LIS() << ' ' << LCS() << endl;
}