最长公共上升子序列 LCIS

参考 ——>百度文库

（说实话这东西真难想，状态定义不好定义，O(N^2)的优化也不好理解）

（好的文章是给不会的人看的）

首先给出状态的定义dp[i][j]，表示以a串的前i个字符b串的前j个字符且以b[j]为结尾构成的LCIS的长度，也就是说以b串为基准。那么在生成的dp二维表中答案就是max(dp[n][1],dp[n][2],dp[n][3]......dp[n][m])。

状态如何转移？也就是怎么整递推式？分两种情况：

a[i]!=b[j]时，dp[i][j]=dp[i-1][j]，也就是说a[i]对dp[i][j]没有什么贡献，根据我们对状态的定义，没有a[i]不影响dp[i][j]。

a[i]==b[j]时，dp[i][j]=max(dp[i-1][k])+1 1<=k<=j-1&&b[j]>b[k] ,这个稍微有点不好理解，当前b[j]==a[i]，那么我们从之前的哪个状态转移过来才能使当前最优呢？换句话说就是在前面找一个最大的LCIS能让b[j]或者a[j]接在后面，来使当前的LCIS最大。

 

分析到这里代码差不多就可以写了：

#include<bits/stdc++.h>
using namespace std;
int a[256],b[256];
int dp[256][256];
int main(){
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	for(int i=1;i<=m;i++){
		cin>>b[i];
	}

	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			if(a[i]!=b[j]){
				dp[i][j]=dp[i-1][j];
			}
			else if(a[i]==b[j]){
				int temp=0;
				for(int k=1;k<j;k++){
					if(b[k]<b[j])
					temp=max(dp[i-1][k],temp);
				}
				dp[i][j]=temp+1;
			}
		}
	}
	int maxx=0;
	for(int i=1;i<=m;i++){
		maxx=max(maxx,dp[n][i]);
	}
	cout<<maxx<<endl;

	return 0;
}

上面是一个O(n^3)的时间复杂度


优化的地方在于如何消掉最内层循环，也就是遍历之前最大LCIS的那部分代码。
 

#include<bits/stdc++.h>
using namespace std;
int a[256],b[256];
int dp[256][256];
int main(){
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	for(int i=1;i<=m;i++){
		cin>>b[i];
	}

	for(int i=1;i<=n;i++){
		int max=0;
		for(int j=1;j<=m;j++){
			dp[i][j]=dp[i-1][j];
			if(a[i]>b[j]&&dp[i-1][j]>max){
				max=dp[i-1][j];
			}
			if(a[i]==b[j]){
				dp[i][j]=max+1;
			}
		}
	}
	int maxx=0;
	for(int i=1;i<=m;i++){
		maxx=max(maxx,dp[n][i]);
	}
	cout<<maxx<<endl;

	return 0;
}

这个代码是真的烧脑，在这里我只能作不够详尽的解释，之后如果悟到点其他的再补充。

在开始那版代码里我们将a[i]和b[j]的关系分为两种情况讨论：等和不等。在相等的时候，需要遍历j之前的k，判断是否存在b[k]使得b[k]<b[j]并且以b[k]结尾的LCIS长度是最大的。那么我们可以使用一个变量计算到当前j时，dp[i-1][k]（1<=k<j）的最大值。

当a[i]==b[j]相等时赋给dp[i][j]就行。

代码中的if(a[i]>b[j]&&dp[i-1][j]>max)是我当时想不明白的地方，可以这样想，现在的max是要给之后a[i]==b[j]用的，而b[k]要小于b[j]，也就是a[i]>b[k]，那么当遇到b[k]<a[i]时就判断dp[i-1][k]和max的大小。

如果a[i]<b[k]不需要管，因为既然a[i]<b[k]那么之后的a[i]==b[j]中b[j]一定大于b[k]，不满足我们要找的递增序列，也就不会把b[k]接在后面。