最长递增子序列

最长递增子序列

http://www.nowcoder.com/questionTerminal/9cf027bf54714ad889d4f30ff0ae5481

两步走:

  1. 第一步——求最长递增子序列长度
  2. 第二步——求字典序靠前的子序列

对于第一步,有两种解法:

  1. 动态规划,时间复杂度为O(n^2),会超时
  2. 贪心+二分,时间复杂度为O(nlogn)

下面说说贪心+二分的解法,举例说明基本思路,假设数组arr为[2, 3, 1, 2, 3],vec数组里面存放递增子序列,maxLen数组里存放以元素i结尾的最大递增子序列长度,那么遍历数组arr并执行如下更新规则:

  1. 初始情况下,vec为[2],maxLen[1]
  2. 接下来遇到3,由于vec最后一个元素小于3,直接更新,vec为[2,3],maxLen[1,2]
  3. 接下来遇到1,由于vec最后的元素大于1, 我们在vec中查找大于等于1的第一个元素的下标,并用1替换之,此时vec为[1,3], maxLen[1,2,1]
  4. 接下来遇到2,由于vec最后的元素大于2,我们在vec中查找大于等于2的第一个元素的下标,并用2替换之,此时vec为[1,2], maxLen[1,2,1,2]
  5. 接下来遇到3,由于vec最后一个元素小于3,直接更新,vec为[1,2,3],maxLen为[1,2,1,2,3]
  6. 此时vec的大小就是整个序列中最长递增子序列的长度(但是vec不一定是本题的最终解)

对于第二步,假设我们原始数组是arr1,得到的maxLen为[1,2,3,1,3],最终输出结果为res(字典序最小的最长递增子序列),res的最后一个元素在arr1中位置无庸置疑是maxLen[i]==3对应的下标,那么到底是arr1[2]还是arr1[4]呢?如果是arr1[2],那么arr1[2]<arr1[4],则maxLen[4]==4,与已知条件相悖。因此我们应该取arr1[4]放在res的最后一个位置。

完整代码如下:

//
// Created by jt on 2020/9/14.
//
#include <vector>
#include <algorithm>
using namespace std;

class Solution {
public:
    /**
     * return the longest increasing subsequence
     * @param arr int整型vector the array
     * @return int整型vector
     */
    vector<int> LIS(vector<int>& arr) {
        // write code here
        // 第一步:利用贪心+二分求最长递增子序列长度
        vector<int> res;
        vector<int> maxLen;
        if (arr.size() < 1) return res;
        res.emplace_back(arr[0]);  // 注:emplace_back(val)作用同push_back,效率更高
        maxLen.emplace_back(1);
        for (int i = 1; i < arr.size(); ++i) {
            if (arr[i] > res.back()) {
                res.emplace_back(arr[i]);
                maxLen.emplace_back(res.size());
            } else {
                // lower_bound(begin, end, val)包含在<algorithm>中
                // 它的作用是返回有序数组begin..end中第一个大于等于val的元素的迭代器
                int pos = lower_bound(res.begin(), res.end(), arr[i]) - res.begin();
                res[pos] = arr[i];
                maxLen.emplace_back(pos+1);
            }
        }
        // 第二步:填充最长递增子序列
        for (int i = arr.size()-1, j = res.size(); j > 0; --i) {
            if (maxLen[i] == j) {
                res[--j] = arr[i];
            }
        }
        return res;
    }
};
刷遍天下无敌手 文章被收录于专栏

秋招刷题历程

全部评论
该题解结合力扣官方题解+代码,看了一个小时才看懂= =
3 回复 分享
发布于 2021-03-22 15:41
首先,哥们你的maxlen并不是代表长度为n数组的递增序列长度,maxlen里面存的是最小字典数组元素的下标。关于长度为n数组的最大递增序列长度还得看动态规划。
1 回复 分享
发布于 2021-10-01 17:09
大佬,为什么贪心第一步时,要把vec数组里第一个大于1的元素换成1呀
1 回复 分享
发布于 2020-10-11 11:24
vec[i] 表示长度为 i+1 的所有上升子序列的末尾元素的最小值
2 回复 分享
发布于 2021-08-15 21:56
大佬,请问为什么“vec不一定是本题的最终解”?
1 回复 分享
发布于 2021-08-12 19:49
666
点赞 回复 分享
发布于 2021-08-02 20:06
补充一个java版的 public static int[] lengthOfLIS(int[] nums) { int len=1, n=nums.length; if (n==0) return null; //表示 可能的最长子序列 int[] d = new int[n+1]; //表示 以该位置结尾的最长子序列长度 int dp[] = new int[n]; d[len] = nums[0]; dp[0] = len; for (int i = 1; i < n; i++) { if (nums[i]>d[len]) { d[++len] = nums[i]; dp[i] = len; } else { int l=1, r=len, pos=0; //pos为d数组中小于nums[i]的前一位 while (l<=r){ int mid = (l+r)>>1; if (d[mid]<nums> 0; i--) { if (dp[i]==j) d[j--] = nums[i]; } int[] res = new int[len]; System.arraycopy(d,1,res,0,len); return res; }</nums>
点赞 回复 分享
发布于 2021-07-26 16:49
这个方法真的是妙啊
点赞 回复 分享
发布于 2021-05-29 17:59
第三步为什么要替换vec里的值 这样递增不就变成递减了
点赞 回复 分享
发布于 2021-05-07 21:39
大佬太强了
点赞 回复 分享
发布于 2021-04-17 17:34
实在是妙!!!贪心求递增子序列长度,maxLen数组反过来递推子序列。 就是这个二分查找直接使用了函数,代码确实简短。 强烈赞一波!!!
点赞 回复 分享
发布于 2021-04-09 10:55
都差不多我这样就超时,这么优化 import java.util.*; public class Solution { /** * retrun the longest increasing subsequence * @param arr int整型一维数组 the array * @return int整型一维数组 */ public int[] LIS (int[] arr) { // write code here if(arr.length<=1) return arr; int[] dp=new int[arr.length]; int max=0; for(int i=0;i<arr.length>=max)max=dp[i]; } int[] res=new int[max]; for(int i=arr.length-1;i>=0;i--){ if(dp[i]==max){ res[--max]=arr[i]; } } return res; } }</arr.length>
点赞 回复 分享
发布于 2021-03-22 20:03

相关推荐

评论
107
25
分享

创作者周榜

更多
牛客网
牛客企业服务