最长上升子序列

最新推荐文章于 2024-04-11 17:06:21 发布

计科1401崔希艺

最新推荐文章于 2024-04-11 17:06:21 发布

阅读量289

点赞数

分类专栏：动态规划

本文链接：https://blog.csdn.net/cui2839255227/article/details/52186053

版权

动态规划专栏收录该内容

5 篇文章 0 订阅

订阅专栏

题目描述

一个数的序列bi，当b ₁ < b ₂ < ... < b _S的时候，我们称这个序列是上升的。对于给定的一个序列(a ₁, a ₂, ..., a _N)，我们可以得到一些上升的子序列(a _i1, a _i2, ..., a _iK)，这里1<= i ₁ < i ₂ < ... < i _K <= N。比如，对于序列(1, 7, 3, 5, 9, 4, 8)，有它的一些上升子序列，如(1, 7), (3, 4, 8)等等。这些子序列中最长的长度是4，比如子序列(1, 3, 5, 8)。

你的任务，就是对于给定的序列，求出最长上升子序列的长度。

输入

输入的第一行是序列的长度N (1 <= N <= 1000)。第二行给出序列中的N个整数，这些整数的取值范围都在0到10000。

输出

最长上升子序列的长度。

题解：这就是一个动态规划的问题，我们可以吧这个序列分为一些小的子序列，当子序列的问题解决了，那么整个序列的问题也就解决了。

对这个题来说，找Ai数之前序列maxlen【】的最大值，然后加上一，就是到Ai的最长子序列。

示例输入

7
1 7 3 5 9 4 8

示例输出

#include<iostream>
#include<cstring>
using namespace std;
int main()
{
    int n,a[10001],maxlen[10001],i,j;
    cin>>n;
    for(i=1;i<=n;i++)
        cin>>a[i];
    maxlen[1]=1;//第一个数的长度肯定为一。
    for(i=2;i<=n;i++)
    {
        int m=0;//定义m的目的就是找最大值。
        for(j=1;j<i;j++)//找i之前的数。
        {
            if(a[i]>a[j])
            {
                if(m<maxlen[j])
                    m=maxlen[j];//m就保留Ai之前的序列的最大值。
            }
        }
        maxlen[i]=m+1;//加一就行。
    }
    int max1=0;
    for(i=1;i<=n;i++)
    {
        if(max1<maxlen[i])
            max1=maxlen[i];
    }
    cout<<max1<<endl;
    return 0;
}

#include<iostream>
#include<cstring>
using namespace std;
int len,arr[1001],behind[1001];//在这个数组里存放子序列长度相等的末尾元素的最小值。
int search1(int i)
{
    int left,right,mid;
    left=0;right=len;
    while(left<right)
    {
        mid=left+(right-left)/2;
        if(behind[mid]>=arr[i])
           right=mid;//这里之所欲不是mid-1，是因为我们要进行元素的插入，找到比插入元素大的下界。
        else
            left=mid+1;
    }
    return left;
}
int main()
{
    int T,i;
    while(cin>>T)
    {
        for(i=1;i<=T;i++)
            cin>>arr[i];
        behind[1]=arr[1];
        len=1;
        for(i=2;i<=T;i++)
        {
            if(arr[i]>behind[len])
                behind[++len]=arr[i];
            else
            {
                int pos=search1(i);
                behind[pos]=arr[i];
            }
        }
        cout<<len<<endl;
    }
    return 0;
}

题解：这个方法相比上一个要节省时间，它利用了二分查找的原理在behind[]数组中找到一个j，是的behind【j-1】<arr[i]<behind[j],然后返回j。

<strong><span style="font-size:18px;">最长上升子序列（LIS）的典型变形，熟悉的n^2的动归会超时。LIS问题可以优化为nlogn的算法。
定义d[k]:长度为k的上升子序列的最末元素，若有多个长度为k的上升子序列，则记录最小的那个最末元素。
注意d中元素是单调递增的，下面要用到这个性质。
首先len = 1,d[1] = a[1],然后对a[i]:若a[i]>d[len]，那么len++，d[len] = a[i];
否则，我们要从d[1]到d[len-1]中找到一个j，满足d[j-1]<a[i]<d[j],则根据D的定义，我们需要更新长度为j的上升子序列的最末元素（使之为最小的）即 d[j] = a[i];
最终答案就是len
利用d的单调性，在查找j的时候可以二分查找，从而时间复杂度为nlogn。</span></strong>