leetcode300. 最长递增子序列

最新推荐文章于 2024-08-12 22:44:27 发布

原创最新推荐文章于 2024-08-12 22:44:27 发布 · 103 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #动态规划

算法设计同时被 2 个专栏收录

127 篇文章

订阅专栏

c/c++

122 篇文章

订阅专栏

本文介绍了一种寻找整数数组中最长严格递增子序列长度的方法。提供了两种解决方案：一种是使用动态规划实现，时间复杂度为O(n^2)；另一种结合了动态规划与二分查找，将时间复杂度降低到了O(nlogn)。两种方法均阐述了详细的实现步骤。

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

题目链接：https://leetcode-cn.com/problems/longest-increasing-subsequence/

题意：

给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

方法一：动态规划，时间复杂度O(n^2)，空间复杂度O(n)

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int dp[2501]={0};//dp数组
        int len = nums.size();//记录元素个数
        int maxL = 1;//最大长度至少为1
        dp[0] = 1;
        for(int i=1;i<len;i++)//遍历数组中的每个元素
        {   
            dp[i] = 1;
            for(int j=0;j<i;j++)//遍历nums[i]之前的每一个元素
            {
                if(nums[i]>nums[j])//如果数组中的数[i]要比前面几个数大，寻找到最大的dp[j]在它的基础上加1，更新到dp[i]中
                    dp[i] = max(dp[i],dp[j]+1);
            }
            maxL = max(maxL,dp[i]);//每一次dp[i]更新完，就更新一下最大值
        }   
        return maxL;
    }
};

方法二：动态规划+二分查找，时间复杂度O(nlogn)，空间复杂度O(n)

构造dp数组，通过lower_bound达到logn的效率，替换掉第一个大于等于nums[i]的元素，每次都这么替换，最后的dp数组中，会找到最优的子序列长度

参考思路：https://www.cnblogs.com/wxjor/p/5524447.html

class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int len = nums.size();//记录元素个数
        vector<int> dp(len,1e9+1);//构造dp数组
        for(int i=0;i<len;i++)//遍历nums每一个元素
        {
            int index = lower_bound(dp.begin(),dp.end(),nums[i])-dp.begin();//记录下第一个大于等于nums[i]的元素的坐标
            dp[index] = nums[i];//替换dp数组中的这个元素
        }
        return lower_bound(dp.begin(),dp.end(),1e9+1)-dp.begin();//返回最大的长度
    }
};