Longest Increasing Subsequence

最新推荐文章于 2022-09-20 20:59:37 发布

__William__

最新推荐文章于 2022-09-20 20:59:37 发布

阅读量4.7k

点赞数

CC 4.0 BY-SA版权

分类专栏： leetcode 文章标签： leetcode

本文链接：https://blog.youkuaiyun.com/willduan1/article/details/53669646

leetcode 专栏收录该内容

35 篇文章

订阅专栏

本文介绍了一种使用O(nlogn)时间复杂度来寻找未排序数组中最长递增子序列长度的方法。通过维护一个非递减数组并运用二分查找技巧，有效地解决了该问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

题目：

给定一个没有排好序的数组，求一个其递增的子序列，返回长度。

使用O(nlogn)的解法。

解题思路：

一般来说，要求使用O(nlogn)时间复杂度的，首先想到二分查找，设置一个非递减的数组。

具体思路看下面的例子。

代码：

 public int lengthOfLIS(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        
        int[] min = new int[nums.length + 1];
        min[0] = Integer.MIN_VALUE;
        for (int i = 1; i < min.length; ++i) {
            min[i] = Integer.MAX_VALUE;
        }
        
        for (int i = 0; i < nums.length; ++i) {
            int index = binarySearch(min, nums[i]);
            min[index] = nums[i];
        }
        
        for (int i = nums.length; i >= 1; --i) {
            if (min[i] != Integer.MAX_VALUE) {
                return i;
            }
        }
        
        return 0;
    }
    //找到大于num的第一个数下标
    private int binarySearch(int[] minLast, int num) {
        int start =0;
        int end = minLast.length - 1;
        int mid;
        while (start + 1 < end) {
            mid = start + ((end - start) >> 1);
            if (minLast[mid] < num) {
                start = mid;
            } else {
                end = mid;
            }
        }
        if (minLast[start] > num) {
            return start;
        }
        return end;
    }

-----------EOF----------