LIS最长上升子序列总结

07-28 LIS 最长上升子序列总结

    • LeetCode 300. 最长上升子序列
    • LeetCode 128. 最长连续序列
    • LeetCode 845. 数组中的最长山脉
    • 解题思路

为了让自己更好的记住学过的知识,我要写博客,将做题中用到的一些方法和一类问题进行总结。

今天做题,碰到了一题关于最长上升子序列的题目,先上题

牛牛现在有一个n个数组成的数列,牛牛现在想取一个连续的子序列,并且这个子序列还必须得满足:最多只改变一个数,就可以使得这个连续的子序列是一个严格上升的子序列,牛牛想知道这个连续子序列最长的长度是多少。

输入描述:

输入包括两行,第一行包括一个整数n(1 ≤ n ≤ 10^5),即数列的长度;
第二行n个整数a_i, 表示数列中的每个数(1 ≤ a_i ≤ 10^9),以空格分割。

输出描述:

输出一个整数,表示最长的长度。

输入例子:

6 
7 2 3 1 5 6

输出例子:

5

对于这类笔试题,目前我也只学习了动态规划、双指针、递归、二分、哈希表、单调队列几个基础方法,具体问题具体分析的能力还得多多锻。用了双指针,可惜只有20%的样例通过,之前没做过LIS的题目,今天先总结一下最长子序列问题(LIS),主要也是以LeetCode上的题目展开,让读到这篇文章的人尽可能的将此问题理解的深点。

LeetCode 300. 最长上升子序列

问题描述

给定一个无序的整数数组,找到其中最长上升子序列的长度。

示例:

输入: [10,9,2,5,3,7,101,18]
输出: 4
解释: 最长的上升子序列是 [2,3,7,101],它的长度是 4。

说明:

  • 可能会有多种最长上升子序列的组合,你只需要输出对应的长度即可。
  • 你算法的时间复杂度应该为 O(n2) 。

进阶: 你能将算法的时间复杂度降低到 O(n log n) 吗?

解决方法
DP动态规划—O(n^2)、二分+贪心法—O(nlogn)、树状数组优化的DP—O(nlogn)

结题思路

最长上升子序列包含的意思

  1. 子序列元素在原数组中的下标是有序的,但不是连续的;
  2. 子序列元素值是上升的。

主要讲一下dp方法,用dp[i]表示以第i个元素结尾的长上升子序列得长度,例如

dp[0]表示[10]的结果是1;

dp[1]表示[10,9]的结果还是1;

dp[2]表示[10,9,5]的结果还是1;

dp[3]表示[10,9,2,5]的结果是2;

dp[4]表示 [10,9,2,5,3]的结果还是2;

dp[5]表示 [10,9,2,5,3,7]的结果是3;

dp[i]的结果与d[0]~dp[i-1]都有关,我们假设0<=j<=i-1;那么我们能够得到

dp状态转移方程:dp[i]=max(dp[i],dp[j]+1);

注意的一点是初始化dp[i]=1;dp的时间复杂度是O(n^2),因此不算最优。

二分+贪心法—O(nlogn)、树状数组优化的DP—O(nlogn)的思路大家可参考LeetCode 300 。

C++代码

#include 
#include 
#include 

using namespace std;
int main()
{
    int n;
    cin>>n;
    
    vector res(n);
    for(int i=0;i>res[i];
    
    int ans=0;
    vector dp(n,1);
    for(int i=0;ires[j])  //res[i]>res[j]说明相对于以j结尾的数组的最长子序列又可以增1啦
                dp[i]=max(dp[i],dp[j]+1);   
        }
        ans=max(ans,dp[i]);
    }
    cout<

LeetCode 128. 最长连续序列

问题描述

给定一个未排序的整数数组,找出最长连续序列的长度。

要求算法的时间复杂度为 O(n)。

示例:

输入: [100, 4, 200, 1, 3, 2]
输出: 4
解释: 最长连续序列是 [1, 2, 3, 4]。它的长度为 4。

解决方法
利用哈希表unordered_set

结题思路

最长上升子序列包含的意思

  1. 子序列元素在原数组中的下标是无序的;
  2. 子序列元素值是递增加1的。

这题的难点在于规定了时间复杂度为O(n),那么排序肯定是用不上了。

这里主要讲一下用unordered_set方法,LeetCode上用的都是unordered——map,感兴趣的可以去查看一下。

解题思路主要是先将数据放到哈希表中。遍历哈希表,对每一个数据左右两边进行查找哈希表,用到了哈希表的count()函数,存在返回>0,反之返回0。知道左右查查找完毕,且每查找到一个数,则都要将其在哈希表中删除。这样才能保证所有的元素只遍历一次,复杂度是O(n)。

C++代码

#include 
#include 
#include 
using namespace std;
int main()
{
    int n;
    cin>>n;

    unordered_set myhash;   //建立哈希表
    int value;
    for(int i=0;i>value;
        myhash.insert(value);
    }

    int ans=1;
    for(auto c:myhash)
    {
        int temp=1;
        for(int j=c-1;myhash.count(j);j--)  //向左遍历
        {
            myhash.erase(j);
            temp++;
        }
        for(int j=c+1;myhash.count(j);j++) //向右遍历
        {
            myhash.erase(j);
            temp++;
        }
        //myhash.erase(c); 不能删除自己,会段错误。
        ans=max(ans,temp);
    }
    cout<

LeetCode 845. 数组中的最长山脉

问题描述

我们把数组 A 中符合下列属性的任意连续子数组 B 称为 “山脉”:

  • B.length >= 3

  • 存在 0 < i < B.length - 1 使得 B[0] < B[1] < … B[i-1] < B[i] > B[i+1] > … > B[B.length - 1]

    (注意:B 可以是 A 的任意子数组,包括整个数组 A。)

给出一个整数数组 A,返回最长 “山脉” 的长度。

如果不含有 “山脉” 则返回 0。

示例 1:

输入:[2,1,4,7,3,2,5]
输出:5
解释:最长的 “山脉” 是 [1,4,7,3,2],长度为 5。

示例 2:

输入:[2,2,2]
输出:0
解释:不含 “山脉”。

提示:

​ 0 <= A.length <= 10000
​ 0 <= A[i] <= 10000

解决方法
利用哈希表unordered_set

结题思路

这题的难度不大,不过是最接近牛牛那题的,算是简单版,难的题目其实也都是从简单的过来的,那么难题的解题方法也是从小的方法合起来解决的,所以多多积累知识点还很重要的。

言归正传,这题的主要解法是用双指针,和上一题有点类似,不过这个不用删除元素。因为约束条件要求山脉的长度>3,那么我们的遍历就从:1<=i<=n-2;

C++代码

#include 
#include 
#include 
#include 
using namespace std;
int main()
{
    int n;
    cin>>n;
    vector res(n);
    for(int i=0;i>res[i];

    if ( n< 3)  return 0;

    int ans = 1;
    for (int i = 1; i < res.size() - 1; i++) {
        if (res[i] > res[i - 1] && res[i] > res[i + 1]) {
            int l = i - 1;
            int r = i + 1;
            while (l > 0 && res[l - 1] < res[l]) {
                l--;
            }
            while (r < res.size() - 1 && res[r] > res[r + 1]) {
                r++;
            }
            ans = max(ans, r - l + 1);
        }
    }
    cout<



这三个题目是LIS问题中比较基础的题目,但是笔试一般不会这么简单,像牛牛这题,就加了一个限制条件—最多只改变一个数,那么这题的解法就变困难些,那么这题该如何解呢?

解题思路

空间换时间,额外建立两个数组,一个left,一个right

left存放得是以第i个元素为结尾点自左向右的最长连续上升子序列(下标连续,值递增)

right存放得是以第i个元素为起始点自左向右的最长连续上升子序列(下标连续,值递增)

以[7 2 3 1 5 6]为例

left[0]=1,right[5]=1

left[1]=1,right[4]=2

left[2]=2,right[3]=3

left[3]=1,right[2]=1

left[4]=2,right[1]=2

left[5]=3,right[0]=1

用的是dp动态规划

状态转移矩阵

​ left[i]=nums[i]>nums[i-1]?left[i-1]+1:1;

​ right[i]=nums[i]

然后得到dp[i]=max(left[i]+right[i]-1);

C++代码

#include 
#include 
#include 
#include 
using namespace std;
int main()
{
    int n;
    cin>>n;
    vector res(n);
    for(int i=0;i>res[i];

    vector left(n);
    vector right(n);

    left[0]=1;
    for(int i=1;ires[i-1]?left[i-1]+1:1;

    right[n-1]=1;
    for(int i=n-2;i>=0;i--)
        right[i]=res[i]0 && i=2)
            ans=max(ans,right[i+1]+left[i-1]+1);
    }
    cout<

以上就是自己对LIS问题的总结,都是一些解决基础问题的方法总结,最近经常用到的方法是动态规划、双指针、哈希表,下次总结一点双指针的问题。

你可能感兴趣的:(笔试,软件,LeetCode,LIS,最长子序列)