LIS(Longest Increasing Sequence)最长上升子序列模型(朴素 + 贪心两种做法)

LIS(Longest Increasing Sequence)

朴素做法O(n^2)

• 状态表示：f[i]表示以a[i]结尾的IS的长度的最大值，或者说是(a[0]~a[i])这一段序列的LIS。
• 状态表示f[i]
  • 集合： 以a[i]结尾的递增子序列
  • 属性： 长度最大值
• 状态计算
  • 当a[pre] < a[i]，f[i] = max(f[i], f[pre] + 1)

#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;

const int N = 1000 + 100;

int a[N], f[N];
int n;

int main()
{
    scanf("%d", &n);
    
    for (int i = 1; i <= n; i ++) scanf("%d", a + i);
    
    for (int i = 1; i <= n; i ++)
    {
        f[i] = 1;
        for (int j = 1; j < i; j ++)
            if (a[j] < a[i]) f[i] = max(f[i], f[j] + 1);
    }
    
    int res = -1;
    for (int i = 1; i <= n; i ++) res = max(res, f[i]);
    
    printf("%d\n", res);
    return 0;
}

贪心做法O(nlogn)

首先要确定一件事情：最长上升子序列遵循如下的单调性：

即LIS的长度越长，那么对应子序列末尾元素的值应该更大。

证明：以下图为例，若b < a，那么a元素可以加在长度为4末尾元素为b的子序列后边，最终的LIS长度为5且末尾元素为a。但这明显与图中不符，所以a > b恒成立。

图片来自https://www.acwing.com/user/myspace/index/1301

该做法蕴含了一个贪心的思想，对于同样长度的子串，我当然希望它的末端越小越好，这样以后我也有更多机会拓展。

示例代码1：

#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;

const int N = 1e5 + 100;

int a[N], f[N];
// f[i] 表示长度为i的LIS的末尾元素。
int n;

int main()
{
    scanf("%d", &n);
    
    for (int i = 1; i <= n; i ++) scanf("%d", a + i);
    // 初始时，长度为1的子序列末尾元素就是a[1]
    f[1] = a[1];
    int cnt = 1;
    // 从第二个元素开始遍历
    for (int i = 2; i <= n; i ++)
    {
        // 若该元素大于最长的子序列末尾元素，就将该元素加入到该序列末尾，
        // 否则，利用二分的方式，从f[]中找到小于该元素的最大值f[j]，将元素a[i]加到a[j]对应的序列的末尾.
        // 注意，加入之后，LIS的长度就发生改变，所以要加入到下一个位置，即f[j + 1] = a[i];
        if (a[i] > f[cnt]) f[++ cnt] = a[i];
        else {
            int l = 1, r = cnt;
            while(l < r)
            {
                int mid = l + r >> 1;
                if (a[i] > f[mid]) l = mid + 1;
                else r = mid;
            }
            f[r] = a[i];
        }
    }
    
    printf("%d\n", cnt);
    return 0;
}

Y总的简洁代码

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010;

int n;
int a[N];
int q[N];

int main()
{
    scanf("%d", &n);
    for (int i = 0; i < n; i ++ ) scanf("%d", &a[i]);

    int len = 0;
    for (int i = 0; i < n; i ++ )
    {
        int l = 0, r = len;
        while (l < r)
        {
            int mid = l + r + 1 >> 1;
            if (q[mid] < a[i]) l = mid;
            else r = mid - 1;
        }
        len = max(len, r + 1);
        q[r + 1] = a[i];
    }

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

    return 0;
}

LIS扩展

1、相邻元素差绝对值不超过d的最长子序列问题

与此题相同的还有 左右不相邻的最长子序列长度

问题描述：

输入数组 A[0:n]和正实数 d,试设计一个动态规划算法输出 A[0:n]的一个最长子序列，使得子序列中相继元素之差的绝对值不超过 d。分析算法的时间复杂度。

这个问题刚开始拿到没啥思路，一直想不到这个问题的最优子结构，后来看到了最长递增子序列问题的解，发现这个问题和最长递增子序列问题的思路类似。

我们来回忆一下最长递增子序列问题，我们在处理这个问题的时候可以进行一些适当的转换。尽管题目要求求A[0:n]的最长递增子序列，但是因为每个序列都有一个处在最后的元素，因此可以转换为求以某个元素结尾的最长递增子序列问题，最后只要一个O（n）的遍历就能得到最长递增子序列了。这么转换的好处是最优子结构一目了然，比如说我们找到了一个最长递增子序列b1b2…bn,那么显然，b1…bn-1为a0…bn-1的最长递增子序列，因为如果不是，那么将更长的和bn组合起来，就得到了一个比b1…bn还长的序列，这与我们的假设矛盾。在找到了最优子结构以后，很容易的可以写出递归式：

设list[i]存储的为以A[i]结尾的最长递增子序列，那么list[i]=max{list[j]}+1(其中j<i,且A[i]>A[j]）如果不存在A[j]那么list[i]=1.

这个算法很简单就能写出来了。

而回过头看这个题，其实并没有啥区别。一个序列a1a2a3…an的最长这个子序列为b1b2b3…bk，那么显然，b1…bk-1是以bk-1结尾的最长这个子序列，证明方法还是复制剪切法。所以我们很容易的可以得到一个递归式：

设dis[i]保存的是以A[i]结尾的最长的这个子序列的长度，那么dis[i]=max{dis[j]}+1 其中j<i且要求满足A[j]与A[i]的差的绝对值小于d.

得到了递归式以后，我们很容易可以得到动态规划算法。

当然，最后还要遍历一下dis数组求出最大值。

原文链接：https://blog.csdn.net/qq_37694390/article/details/80637038