线性dp典中典题目 最长公共子序列（LCS）

最长公共子序列（LCS）

一道模板题

解法一：

线性动态规划：复杂度为（n^2），写这道模板题，TLE+MLE；

思路，我们可以用dp[i][j]来表示第一个串的前i位、第二个串的前j位的LCS的长度，那么我们是很容易想到状态转移方程：

（1）如果当前的A1[i]和A2[j]相同（即是有新的公共元素） 那么

dp[i][j]=max(dp[i][j],dp[i−1][j−1]+1);

（2）如果不相同，即无法更新公共元素，考虑继承：

dp[i][j]=max(dp[i−1][j],dp[i][j−1]);

代码：

#include<bits/stdc++.h>
#define LL long long
#define pa pair<int,int>
#define lson k<<1
#define rson k<<1|1
//ios::sync_with_stdio(false);
using namespace std;
const int N=1000100;
const int M=200100;
const LL mod=1e9+7;
int dp[10010][10010];
int a[50010],b[50010];
int main(){
	ios::sync_with_stdio(false);
	int n;
	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++){
			dp[i][j]=max(dp[i-1][j],dp[i][j-1]);//在没有匹配的时候；
			if(a[i]==b[j]){//匹配了 
				dp[i][j]=max(dp[i][j],dp[i-1][j-1]+1);
			} 
		}
	}
	cout<<dp[n][n]<<endl;
	return 0;
}

解法二：

拿那道模板题来说，两个串都是1–n的全排列，两个串的元素一样，就是顺序不一样而已；那么我们是不是可以用第一个串为标准，来匹配第二个串；

比如它的样例：3 2 1 4 5 我们把他变成 1 2 3 4 5 用一个数组记录一下每个数字变成了什么，相当于离散化了一下3-1；2-2；1-3；4-4；5-5；

现在我们的第二串1 2 3 4 5 按我们离散化的表示：3 2 1 4 5

所以我们只要离散化第一个串，然后求第二个串的最长上升子序列（LIS）；

复杂度为（nlogn）;

这道题跟LIS最大的区别就是离散化方式不一样；

代码：

#include<bits/stdc++.h>
#define LL long long
#define pa pair<int,int>
#define lson k<<1
#define rson k<<1|1
//ios::sync_with_stdio(false);
using namespace std;
const int N=100100;
const int M=200100;
const LL mod=1e9+7;
int a[N],b[N],c[N],d[N];
int sta[N];//栈，保存的是元素的下标 
int main(){
	ios::sync_with_stdio(false);
	int n;
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
		c[a[i]]=i;//离散化 
	}
	for(int i=1;i<=n;i++){
		cin>>b[i];
		d[i]=c[b[i]];//离散化 
	}
	int ans=0;//栈顶 
	for(int i=1;i<=n;i++){
		if(ans==0||sta[ans]<d[i]){
			sta[++ans]=d[i];//入栈 ，保证栈中元素的递增，这里的元素为数组的下标；
		}
		else{
			*upper_bound(sta+1,sta+ans+1,d[i])=d[i];//替换 
		}
	}
	cout<<ans<<endl;
	return 0;
}