我的算法不可能这么简单—最长递增子序列(LIS)

最长递增子序列

最长递增子序列（Longest Increasing Subsequence,LIS）问题：给定一个长度位 N 的数组，找出一个最长的单调递增子序列。例如一个长度位 7 的序列 A = {5,6,7,4,2,8,8}，它的最长的单调递增子序列为 {5,6,7,8}，长度为4。

#define MAX 100010

static int arr[MAX]; //arr从下标1开始输入，即arr[0]作废
static int n;//序列长度

int LIS()//最长递增子序列
{
    int len = 1;
    int d[MAX];
    d[1] = arr[1];
    for(int i=2;i<=n;i++){
        if(arr[i]>d[len]) //如果改为 arr[i]>=d[len] 即为最长不递减子序列 
            d[++len] = arr[i];
        else{
            int j = lower_bound(d+1,d+len+1,arr[i])-d;
            d[j] = arr[i];
        }
    }
    return len;
}

时间复杂度O(nlog₂n)

最长不减子序列

最长不减子序列，从名字就能看出来，就是一个无减子序列，这个子序列里面的值可能出现连续相等的情况。还是上面的例子一个长度位 7 的序列 A = {5,6,7,4,2,8,8}，它的最长不减子序列为 {5,6,7,8,8}，长度为5。

• 代码与最长递增子序列几乎一致，只是差了个等号，在注释里已经标注。

最长递减子序列

定义与最长递增子序列相反，代码实现也类似

#define MAX 100010

static int arr[MAX]; //arr从下标1开始输入，即arr[0]作废
static int n;//序列长度

int LDS()//最长递减子序列
{
    int len=1;
    int d[MAX];
    d[1] = arr[1];
    for(int i=2; i<=n; i++){
        if(d[len]>arr[i]) //如果改为d[len]>=arr[i] 即为最长不递增子序列
            d[++len]=arr[i];
        else {
            int j=upper_bound(d+1,d+1+len,arr[i],greater<int>())-d;
            //数组d为递减序列，使用upper_bound时需要加上greater<int>()表示大于关系
            d[j]=arr[i];
        }
    }
    return len;
}

时间复杂度O(nlog₂n)

最长不增子序列

与最长不减子序列相反

• 代码与最长递减子序列几乎一致，只是差了个等号，在注释里已经标注。

例题

洛谷P1020

题目描述

某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。某天，雷达捕捉到敌国的导弹来袭。由于该系统还在试用阶段，所以只有一套系统，因此有可能不能拦截所有的导弹。

输入导弹依次飞来的高度（雷达给出的高度数据是≤50000的正整数），计算这套系统最多能拦截多少导弹，如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。

输入格式

1行，若干个整数（个数≤100000）

输出格式

2行，每行一个整数，第一个数字表示这套系统最多能拦截多少导弹，第二个数字表示如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。

输入输出样例

输入 #1

389 207 155 300 299 170 158 65

输出 #1

6
2

解析

最多能拦截多少子弹，即求序列的最长不增序列。
最少需要多少导弹系统，即求序列的最长递增序列。

AC code

#include<bits/stdc++.h>

using namespace std;
#define MAX 100010

static int arr[MAX];//数组arr从1开始，即arr[0]弃用
static int n;//记录序列个数

int LIS()//最长递增子序列
{
    int len = 1;
    int d[MAX];
    d[1] = arr[1];
    for(int i=2;i<=n;i++){
        if(arr[i]>d[len])
            d[++len] = arr[i];
        else{
            int j = lower_bound(d+1,d+len+1,arr[i],less<int>())-d;
            d[j] = arr[i];
        }
    }
    return len;
}

int LNIS()//最长不增子序列
{
    int len=1;
    int d[MAX];
    d[1] = arr[1];
    for(int i=2; i<=n; i++){
        if(d[len]>=arr[i])
            d[++len]=arr[i];
        else {
            int j=upper_bound(d+1,d+1+len,arr[i],greater<int>())-d;
            d[j]=arr[i];
        }
    }
    return len;
}

int main()
{
    ios::sync_with_stdio(false);

    while(cin>>arr[++n]);
    n--;

    cout<<LNIS()<<endl;
    cout<<LIS()<<endl;
    return 0;
}