最长公共子序列 朴素+优化

P1439 【模板】最长公共子序列 - 洛谷

朴素的O(n^2)

const int N = 1e5 + 10;

int n;
int a[N],b[N];
int dp[N][N];

void solve()
{
	cin >> n;
	
	for (int i = 1;i <= n;i ++) cin >> a[i];
	for (int i = 1;i <= n;i ++) cin >> b[i];
	
	for (int i = 1;i <= n;i ++)
		for (int j = 1;j <= n;j ++)
		{
			if (a[i] == b[j]) dp[i][j] = dp[i - 1][j - 1] + 1;
			else dp[i][j] = max(dp[i - 1][j],dp[i][j - 1]);
		}
	cout << dp[n][n] << endl;
} 

优化(nlogn) 

详解最长公共子序列问题（三种方法）-优快云博客

参考dalao的第三种方法，将最长公共子序列问题转换为最长上升子序列问题(前提a，b的数据范围必须相同)

上面解决最长公共子序列问题的算法可简称为LCS。我们还有另一种巧妙的方法来解决这类问题，就是将LCS转化为LIS。什么是LIS呢？LIS是解决最长递增（或不下降）子序列的算法。LIS算法的核心思想也是动态规划。我们先来讲讲转化的过程：

能够转化的前提是序列A和序列B的数据范围必须相同

我们仍以 3 2 1 4 5 和 1 2 3 4 5 为例

A: 3 2 1 4 5

B: 1 2 3 4 5

我们把A中的数据按顺序变成1、2、3、4、5（变成递增顺序），即3 -> 1，2 -> 2，1 -> 3，4 -> 4，5 -> 5；然后B按照A的转化规则进行转化，于是变成：

A: 1 2 3 4 5
B: 3 2 1 4 5

这样标号之后，序列的长度显然不会改变。但是出现了一个性质：两个序列的子序列，一定是A的子序列。而A本身就是递增的，因此这个子序列是递增的。换句话说，只要这个子序列在B中递增，它就是A的子序列。于是，问题就转化成了求B中的最长递增子序列。

你可能觉得这样的转化多此一举，但请注意，解决最长递增子序列类问题，时间复杂度最低可以达到 O(nlogn)；也就是说，用这种方法，我们可以将求解最长公共子序列问题的时间复杂度降为O(nlogn)，这样在处理相关问题时就可以避免时间超限的情况。

但新的问题又来了，怎么在O(nlogn)时间复杂度内求解最长递增子序列问题？这里，我参考了别人给出的一个解释：

我们以数列 5 2 3 1 4 为例

首先，把 5 加入答案序列中，然后遍历到 2，发现 2<5 , 于是，我们用2替换5；然后加3，发现3>2，所以直接把3加到答案序列中，这时候就是 [2,3] ;然后遍历到1，我们发现1<3，于是我们找到一个最小的但是比1大的数字2，然后把1替换2，为什么这么做不会影响结果呢？你可以这么想，我们当前已经求出了一个当前最优的序列，如果我们用1替换2，然后后面来一个数字替换了3，那么我们就可以得到一个更优的序列，而如果没有数字替换3，那么这个1替换2也就是没有贡献的，不会影响我们结果的最优性。另外，解题时可以直接使用STL的lower_bound函数来找到一个最小的但是大于某个数字的数。

const int N = 1e5 + 10;

int n;
int a[N],b[N];
map<int,int> mp;
int stk[N],top;

void solve()
{
	cin >> n;
	for (int i = 1;i <= n;i ++)
	{
		cin >> a[i];
		mp[a[i]] = i;
	}	
	
	for (int i = 1;i <= n;i ++)
	{
		cin >> b[i];
		b[i] = mp[b[i]];
	}
	
	int ans = 0;
	for (int i = 1;i <= n;i ++)
	{
		int pos = upper_bound(stk + 1,stk + 1 + top,b[i]) - stk;
		if (pos == top + 1) ++top;
		stk[pos] = b[i];
		
		ans = max(ans,top);
	}
	
	cout << ans << endl;

}