最长上升子序列LIS-CSDN博客

本文链接：https://blog.csdn.net/qq_40147092/article/details/109284269

三种方法：dp、贪心+二分、树状数组维护
LIS序列不一定唯一，但是长度是唯一的

dp($n^{2}$)

F[i]代表以A[i]结尾的LIS的长度
状态转移：$F[i]=max(F[j]+1,F[i]) \quad 1<=j<i$
边界处理：$F[i]=1 \quad 1<=i<=n$

#include <iostream>

#include <cstdio>

#include <algorithm>

#include <cstdlib>

#include <cstring>

#include <cmath>

using namespace std;

const int maxn = 103, INF = 0x7f7f7f7f;

int a[maxn], f[maxn];

int n,ans = -INF;

int main()

{

    scanf("%d", &n);

    for(int i=1; i<=n; i++) 

    {

        scanf("%d", &a[i]);

        f[i] = 1;

    }

    for(int i=1; i<=n; i++)

        for(int j=1; j<i; j++)

            if(a[j] < a[i])

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

    for(int i=1; i<=n; i++) 

        ans = max(ans, f[i]);

    printf("%d\n", ans);

    return 0;

}

贪心+二分($nlogn$)

新建一个 low 数组，low [ i ]表示长度为i的LIS结尾元素的最小值。对于一个上升子序列，显然其结尾元素越小，越有利于在后面接其他的元素，也就越可能变得更长。因此，我们只需要维护 low 数组，对于每一个a[ i ]，如果a[ i ] > low [当前最长的LIS长度]，就把 a [ i ]接到当前最长的LIS后面，即low [++当前最长的LIS长度] = a [ i ]。

那么，怎么维护 low 数组呢？

对于每一个a [ i ]，如果a [ i ]能接到 LIS 后面，就接上去；否则，就用 a [ i ] 取更新 low 数组。具体方法是，在low数组中找到第一个大于等于a [ i ]的元素low [ j ]，用a [ i ]去更新 low [ j ]。如果从头到尾扫一遍 low 数组的话，时间复杂度仍是O(n^2)。我们注意到 low 数组内部一定是单调不降的，所有我们可以二分 low 数组，找出第一个大于等于a[ i ]的元素。二分一次 low 数组的时间复杂度的O(lgn)，所以总的时间复杂度是O(nlogn)。
　　我们再举一个例子：有以下序列A[ ] = 3 1 2 6 4 5 10 7，求LIS长度。
　　我们定义一个B[ i ]来储存可能的排序序列，len 为LIS长度。我们依次把A[ i ]有序地放进B[ i ]里.(为了方便，i的范围就从1~n表示第i个数)

A[1] = 3，把3放进B[1]，此时B[1] = 3，此时len = 1，最小末尾是3

A[2] = 1，因为1比3小，所以可以把B[1]中的3替换为1，此时B[1] = 1，此时len = 1，最小末尾是1

A[3] = 2，2大于1，就把2放进B[2] = 2，此时B[ ]={1,2}，len = 2

同理，A[4]=6，把6放进B[3] = 6，B[ ]={1,2,6}，len = 3

　　A[5]=4，4在2和6之间，比6小，可以把B[3]替换为4，B[ ] = {1,2,4}，len = 3

　　A[6] = 5，B[4] = 5，B[ ] = {1,2,4,5}，len = 4

　　A[7] = 10，B[5] = 10，B[ ] = {1,2,4,5,10}，len = 5

　　A[8] = 7，7在5和10之间，比10小，可以把B[5]替换为7，B[ ] = {1,2,4,5,7}，len = 5

最终我们得出LIS长度为5。但是，但是！！这里的1 2 4 5 7很明显并不是正确的最长上升子序列。是的，B序列并不表示最长上升子序列，它只表示相应最长子序列长度的排好序的最小序列。这有什么用呢？我们最后一步7替换10并没有增加最长子序列的长度，而这一步的意义，在于记录最小序列，代表了一种“最可能性”。假如后面还有两个数据8和9，那么B[6]将更新为8，B[7]将更新为9，len就变为7，可以自行体会它的作用。

因为在B中插入的数据是有序的，不需要移动，只需要替换，所以可以用二分查找插入的位置，那么插入n个数的时间复杂度为〇(logn)，这样我们会把这个求LIS长度的算法复杂度降为了〇(nlogn)。

lower_bound(startPos,endPos,value):在区间[startPos,endPos)[startPos,endPos) [startPos, endPos)[startPos,endPos)内找到第一个大于等于valuevalue,如果找不到则返回endPosendPos

upper_bound(startPos,endPos,value) [startPos, endPos)[startPos,endPos)内找到第一个大于valuevalue,如果找不到则返回endPosendPos


#include<stdio.h>  

#include<string.h>  

#include<algorithm>  

  

using namespace std;  

  

int num[10]={3,6,3,2,4,6,7,5,4,3};  

  

const int INF=0x3f3f3f3f;  

int l=10, g[100], d[100];  

 

int main()  

{  

    fill(g, g+l, INF);  

    int max_=-1;  

    for(int i=0; i<l; i++)  

    {  

        int j = lower_bound(g, g+l, num[i]) - g;  

        d[i] = j+1;  

        if(max_<d[i])  

            max_=d[i];  

        g[j] = num[i];  

    }  

    printf("%d\n", max_);  

    return 0;  

}  



这里主要注意一下lower_bound函数的应用，注意减去的g是地址。

地址 - 地址 = 下标。

树状数组维护($nlogn$)

我们再来回顾O($n^{2}$)DP的状态转移方程：$F[i]=max(F[j]+1,F[i]) \quad 1<=j<i$
我们在递推F数组的时候，每次都要把F数组扫一遍求F[ j ]的最大值，时间开销比较大。我们可以借助数据结构来优化这个过程。用树状数组来维护F数组(据说分块也是可以的，但是分块是$O(n\sqrt{n})$的时间复杂度，不如树状数组跑得快)，首先把A数组从小到大排序，同时把A[ i ]在排序之前的序号记录下来。然后从小到大枚举A[ i ]，每次用编号小于等于A[i]编号的元素的LIS长度+1来更新答案，同时把编号小于等于A[ i ]编号元素的LIS长度+1。因为A数组已经是有序的，所以可以直接更新。有点绕，具体看代码。

还有一点需要注意：树状数组求LIS不去重的话就变成了最长不下降子序列了。


#include <iostream>

#include <cstdio>

#include <algorithm>

#include <cstdlib>

#include <cstring>

#include <cmath>

using namespace std;

const int maxn =103,INF=0x7f7f7f7f;

struct Node{

    int val,num;

}z[maxn]; 

int T[maxn];

int n;

bool cmp(Node a,Node b)

{

    return a.val==b.val?a.num<b.num:a.val<b.val;

}

void modify(int x,int y)//把val[x]替换为val[x]和y中较大的数 

{

    for(;x<=n;x+=x&(-x)) T[x]=max(T[x],y);

}

int query(int x)//返回val[1]~val[x]中的最大值 

{

    int res=-INF;

    for(;x;x-=x&(-x)) res=max(res,T[x]);

    return res;

}

int main()

{

    int ans=0;

    scanf("%d",&n);

    for(int i=1;i<=n;i++)

    {

        scanf("%d",&z[i].val);

        z[i].num=i;//记住val[i]的编号，有点类似于离散化的处理，但没有去重 

    }

    sort(z+1,z+n+1,cmp);//以权值为第一关键字从小到大排序 

    for(int i=1;i<=n;i++)//按权值从小到大枚举 

    {

        int maxx=query(z[i].num);//查询编号小于等于num[i]的LIS最大长度

        modify(z[i].num,++maxx);//把长度+1，再去更新前面的LIS长度

        ans=max(ans,maxx);//更新答案

    }

    printf("%d\n",ans);

    return 0;

}