LIS的几种不同复杂度解法

看博文的时候一直在默默嘀咕，lis是什么。LIS（longest increasing subsequence）：最长上升子序列。

这篇博文又碰到一个LCS（Longest common subsequence）：最长公共子序列。

 

转载于：https://blog.csdn.net/NOIAu/article/details/72870205

---

LIS通常的一种n^2解法

No.1

#include<cstdio>
#include<iostream>
#include<cstring>
#define MAXN 100000+10
using namespace std;
int n,a[MAXN],dp[MAXN];

int main(){
    ios::sync_with_stdio(false);
    cin>>n;
    for(register int i=1;i<=n;i++)cin>>a[i];
    for(register int i=1;i<=n;i++) dp[i]=1;
    for(register int i=1;i<=n;i++)
    for(register int j=1;j<i;j++)
        if(a[i]>a[j]) dp[i]=max(dp[i],dp[j]+1); 
    cout<<dp[n]<<endl;
    return 0;
}

以及另一种比较巧妙，将其转化为求LCS的算法，也就是先排序，然后LCS一遍，然而还是O（n^2）的复杂度

---

No.2

#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#define MAXN 1000+10
using namespace std;
int n,a[MAXN],b[MAXN],dp[MAXN][MAXN];

int main(){
    ios::sync_with_stdio(false);
    cin>>n;
    for(register int i=1;i<=n;i++)cin>>a[i],b[i]=a[i];
    sort(b+1,b+n+1);
    for(register int i=1;i<=n;i++)
        for(register int j=1;j<=n;j++)
            if(a[i]==b[j])
                dp[i][j]=dp[i-1][j-1]+1;
            else
                dp[i][j]=dp[i-1][j]>dp[i][j-1]?dp[i-1][j]:dp[i][j-1];
    cout<<dp[n][n]<<endl;
    return 0;
}

LIS（最长上升子序列）通常有如上所述的n^2的解法，这里再介绍几种（我也不知道是几种）nlogn解法

---

No.3

我们有这样一种思路，如果同样长度的LIS，如果该LIS序列的最后一位越小，他的“潜力”就越大，也就是说，对于dp[i]来说，如果在前i个数中有几种LIS解法，但是某一种的末尾的元素最小，我们就认为该元素的序列是较优的LIS，显然想到单调的数据结构来处理 
代码如下

#include<cstdio>
#include<iostream>
#include<cstring>
#define MAXN 10000+10
int lis[MAXN],a[MAXN],n;
using namespace std;
int len;
int find(int i){
    int l,r,m;
    l=0,r=len;
    while(l<r){
        m=l+r>>1;
        if(lis[m]>=a[i]) r=m;//大了就递归左区间,找到第一个比它小的;
        else l=m+1;
    }
    return l;
}
int main(){
    scanf("%d",&n);
    for(register int i=1;i<=n;i++) scanf("%d",&a[i]);
    lis[1]=a[1];len++;
    for(register int i=2;i<=n;i++){
        if(a[i]>lis[len])
            lis[++len]=a[i];//该长度lis的目前最优顶端元素 
        else{
            int pos=find(i);//对于一个a[i],可以更新以它为结尾的最长lis结尾
            lis[pos]=a[i];//a[i]要小于查找出来的lis[pos],于是以a[i]更新lis[pos] 
        }
    }
    printf("%d",len);
    return 0; 
} 

显然，我们维护的这个数组lis是单调的

---

No.4

还可以用stl自带的lower_bound进行处理 
代码如下

#include<cstdio>
#include<iostream>
#include<cstring>
#define MAXN 10000+10
int lis[MAXN],a[MAXN],n;
using namespace std;
int len;
int find(int i){
    int l,r,m;
    l=0,r=len;
    while(l<r){
        m=l+r>>1;
        if(lis[m]>=a[i]) r=m;
        else l=m+1;
    }
    return l;
}
int main(){
    scanf("%d",&n);
    for(register int i=1;i<=n;i++) scanf("%d",&a[i]);
    lis[1]=a[1];len++;
    for(register int i=2;i<=n;i++){
        if(a[i]>lis[len])
            lis[++len]=a[i];
        else{
            int pos=lower_bound(lis+1,lis+len,a[i])-lis;
            lis[pos]=a[i];
        }
    }
    printf("%d",len);
    return 0; 
} 

---

既然是找之前的最大的值，我们显然还可以维护一个最大值，线段树版本可以，平衡树版本可以，树状数组版本可以，单调栈版本可以，单调队列版本可以（出队条件是当前位的最后一位有更小的去更新它），set版本也可以，优先队列版本也可以 
（以上所述一些数据结构可能首元素并不是满足a[j]>a[i]的情况，要线性遍历，满足条件即break，期望复杂度也是比n^2小很多的）