LeetCode-300-最长递增子序列

本文介绍了如何解决LeetCode中的第300题——最长递增子序列。文章详细阐述了两种解决方案:1) 动态规划,使用一个dp数组维护以当前元素为结尾的最长递增子序列的长度;2) 贪心策略结合二分查找,维护一个严格递增的tail数组,通过替换元素找到最长递增子序列的长度。这两种方法的时间复杂度分别为O(n*n)和O(nlogn)。通过具体示例解释了算法的运行过程,证明了元素替换不会影响最终结果。

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

LeetCode-300-最长递增子序列

在这里插入图片描述

思路

1.动态规划:O(n*n)
题目要求找出的是递增子序列,子序列不一定是连续的,但是要保证递增,因此可以用动态规划来维护一个不断更新的dp数组,该数组表示,以当前元素为最后一个元素的子序列的最大长度

2.贪心+二分查找:O(nlogn)
遍历数组,然后维护一个tail[]数组,tail数组必须是严格递增的
当nums[i]>tail[len]时,tail[len+1]=nums[i],tail数组长度加1
当nums[i]<=tail[len]时,通过二分查找,把nums[i]替换tail数组中合适的元素

如序列 1,101,102,2,3,4,999
原数组每次遍历输出的tails为:
1
1,101
1,101,102
1,2,102
1,2,3
1,2,3,4
1,2,3,4,999

可能会担心这个替换会导致子序列不成立,但是其实tail数组所产生的序列并不一定是最长的递增子序列,我们所需要的只是它的长度,因为每次长度变化都是表示遍历到当前位置时的最大长度,我们已经得到这个长度了,前面的元素发生替换并不会产生影响,反而是推动了找到最长递增子序列
参考下列例子

如序列 1,4,3,13,2,5
1
1,4
1,3
1,3,13
1,2,13
1,2,5
可见,元素替换并不会导致不好的影响

代码

//1.动态规划:O(n*n)
class Solution {
    public int lengthOfLIS(int[] nums) {
        if(nums==null||nums.length==0)return 0;
        int []dp=new int[nums.length];
        int res=1;
        for(int i=0;i<nums.length;i++){
            dp[i]=1;//至少为1,表示自己
            for(int j=0;j<i;j++){
                if(nums[j]<nums[i]){
                    dp[i]=Math.max(dp[i],dp[j]+1);//更新dp[i]
                }
            }
            res=Math.max(dp[i],res);//更新最大值
        }
        return res;
    }
}
//2.贪心+二分查找:O(nlogn)
class Solution {
    public int lengthOfLIS(int[] nums) {
        if(nums==null||nums.length==0)return 0;
        int len=1,n=nums.length;
        int []tail=new int[n+1];
        tail[len]=nums[0];
        for(int i=1;i<n;i++){
            if(nums[i]>tail[len]){
                tail[++len]=nums[i];
            }
            else{
                //二分查找位置
                int l=1,r=len,pos=0;
                while(l<=r){
                    int mid=l+(r-l)/2;
                    if(tail[mid]<nums[i]){
                        pos=mid;
                        l=mid+1;
                    }
                    else{
                        r=mid-1;
                    }
                }
                tail[pos+1]=nums[i];
            }
        }

        return len;
    }
}
LeetCode 题目 491 - 递增子序列 (Incremental Subsequence) 是一道关于算法设计的中等难度题目。这道题要求你在给定整数数组 nums 中找出所有长度大于等于 1 的递增子序列递增子序列是指数组中的一串连续元素,它们按照顺序严格增大。 解决这个问题的一个常见策略是使用动态规划(Dynamic Programming),特别是哈希表或者单调栈(Monotonic Stack)。你可以维护一个栈,每当遍历到一个比栈顶元素大的数字时,就将它推入栈,并更新当前最长递增子序列的长度。同时,如果遇到一个不大于栈顶元素的数字,就从栈顶开始检查是否存在更长的递增子序列。 以下是 C++ 解决此问题的一种简单实现: ```cpp class Solution { public: vector<int> lengthOfLIS(vector<int>& nums) { int n = nums.size(); if (n == 0) return {}; // 使用单调栈存储当前已知的最大子序列 stack<pair<int, int>> stk; stk.push({nums[0], 1}); for (int i = 1; i < n; ++i) { while (!stk.empty() && nums[i] > stk.top().first) { // 如果新数大于栈顶元素,找到一个更长的递增子序列 int len = stk.top().second + 1; ans.push_back(len); stk.pop(); } // 如果新数不大于栈顶元素,尝试从当前位置开始寻找更长子序列 if (!stk.empty()) { stk.top().second = max(stk.top().second, 1); } else { stk.push({nums[i], 1}); } } return ans; } private: vector<int> ans; }; ``` 在这个解决方案中,`ans` 存储所有的递增子序列长度,最后返回这个结果向量即可。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值