leetcode 300 最长递增子序列 动态规划+二分优化

最新推荐文章于 2024-07-19 11:09:08 发布
最新推荐文章于 2024-07-19 11:09:08 发布
阅读量829 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： LeetCode dp 二分 文章标签： leetcode 最长上升子序列 dp 二分
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/TIMELIMITE/article/details/124074991
这篇博客探讨了如何使用动态规划优化求解最长公共子序列问题，首先介绍了基本的经典动态规划解法，然后详细讲解了如何通过维护一个最长上升序列来进一步优化算法，从而提高效率。内容包括如何判断新元素是否能延伸序列，以及如何利用二分查找在序列中找到合适位置插入新元素。

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

// 经典dp
// dp[i]表示以i为结尾的最长公共子序列长度
// dp[i] = max(dp[j]) + 1 if (a[i] > a[j])
// 否则dp[i] = 1
// 优化版在后面

//class Solution {
//public:
//    int lengthOfLIS(vector<int>& nums) {
//        int n = nums.size();
//        vector<int> dp(n + 1);
//        int res = 0;
//        for (int i = 1; i <= n; i++) {
//            int mx = 1;
//            for (int j = i - 1; j >= 0; j--) {
//                if (mx <= dp[j + 1] && nums[j] < nums[i - 1]){
//                    mx = dp[j + 1] + 1;
//                }
//            }
//            dp[i] = mx;
//            res = std::max(res, dp[i]);
//        }
//        return res;
//    }
//};

// 优化版
// 直接维护一个最长上升序列
// 此时dp就是最长上升序列
// 如果nums[i] > dp序列中最后一个数
// 将nums[i]添加到dp中
// 否则二分查找, 将nums[i]加到第一个不大于nums[i]的位置
// lower_bound(a, a + n, x) - a;
// 返回在a数组中[0, n)中第一个大于等于x的下标
class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        int n = nums.size();
        vector<int> dp(n);
        vector<int>::iterator low;
        int len = 1;
        dp[0] = nums[0];
        int pos;
        for (int i = 1; i < n; i++) {
            if (nums[i] > dp[len - 1])
                dp[len++] = nums[i];
            else {
                pos = lower_bound(dp.begin(), dp.begin() + len, nums[i]) - dp.begin();
                dp[pos] = nums[i];
            }

        }
        return len;
    }
};

LeetCode 最长递增子序列的个数（动态规划）
hestyle的博客
04-19 1228
给定一个未排序的整数数组，找到最长递增子序列的个数。 示例 1: 输入: [1,3,5,4,7] 输出: 2 解释: 有两个最长递增子序列，分别是 [1, 3, 4, 7] 和[1, 3, 5, 7]。 示例 2: 输入: [2,2,2,2,2] 输出: 5 解释: 最长递增子序列的长度是1，并且存在5个子序列的长度为1，因此输出5。 注意: 给定的数组长度不超过 2000 并且结果一定是32...
LeetCode 300. 最长递增子序列（附带打印字典序最小的序列，动态规划，贪心+二分）
m0_37433111的博客
09-17 1012
2020年9月17日 周四 天气晴 【不悲叹过去，不荒废现在，不惧怕未来】 本文目录1. DP2. 贪心 + 二分查找参考文献 1. DP DP法关键在于如何定义状态，由于一个子序列一定会以一个数结尾，于是将状态定义成：dp[i] 表示以 nums[i] 结尾的「上升子序列」的长度。注意：这个定义中 nums[i] 必须被选取，且必须是这个子序列的最后一个元素。 class Solution { public: int lengthOfLIS(vector<int>& num
麻烦的聚餐（最长递增子序列+二分优化）
蔡军帅
05-05 386
麻烦的聚餐（最长递增子序列+二分优化） 麻烦的聚餐 题目描述 为了避免餐厅过分拥挤，FJ要求奶牛们分3批就餐。每天晚饭前，奶牛们都会在餐厅前排队入内，按FJ的设想，所有第3批就餐的奶牛排在队尾，队伍的 前端由设定为第1批就餐的奶牛占据，中间的位置就归第2批就餐的奶牛了。由于奶牛们不理解FJ的安排，晚饭前的排队成了一个大麻烦。 第i头奶牛有一张标明她用餐批次D_i(...
最长单调递增子序列（二分查找优化）
飘过的小牛
05-09 2273
二分查找优化后的最长递增子序列
最长递增子序列的优化——时间复杂度为O(nlogn)
<WRM>的博客
01-28 618
//最长递增子序列的优化——时间复杂度为O(nlogn) #include<stdio.h> #include<iostream> #include<string> using namespace std; const int MAXN = 1000+10; const int INF = INT_MAX; int support[MAXN]; int arr[MAXN]; int main() { int n; support[0] = -INF; for
leetCode 300 最长递增子序列（dp，二分查找）
在森林里麋了鹿
04-04 285
题目链接：点击查看 题目描述： 给定一个未排序的整数数组，求最长的递增子序列。 输入输出： 输入：nums = [10,9,2,5,3,7,101,18] 输出：4 输入：nums = [0,1,0,3,2,3] 输出：4 注意事项：按照 LeetCode 的习惯，子序列（subsequence）不必连续，子数组（subarray）或子字符串 （substring）必须连续 题目分析： 对于子序列问题，第一种动态规划方法是，定义一个 dp 数组，其中 dp[i] 表示以 i 结尾的子
力扣 leetcode 300. 最长递增子序列（python）
weixin_50791900的博客
07-18 2354
Topic 给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。 子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] Example_1 输入：nums = [10,9,2,5,3,7,101,18] 输出：4 解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。 Example_2 输入：nums = [0,1,0,3,2,3] 输出：4 Example_3 输入：num
DP、二分-LeetCode300. 最长上升子序列（Python）
12-21
二分查找通常用于在有序数组中查找特定值，但在本题中，我们利用其高效的查找效率来优化动态规划的解决方案。我们可以维护一个有序的尾巴数组`tails`，它记录了当前所有可能的上升子序列的最后一个元素。对于每个...
Leetcode—300. 最长递增子序列【中等】（ranges::max()、ranges::lower_bound())
Atticus的博客
07-19 356
运行结果 运行结果 运行结果 运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
LIS - 最长上升子序列 （二分优化）
weixin_34293059的博客
07-15 188
题目：长度为n的序列a1, a2, ..., an,选出满足 j < i 时, a[j] < a[i] 最长子序列分析：当选择第i个时候，在j<i中，选出a[j]<a[i]的数加入，维护最大长度状态：dp[i]表示以i为终点的最大上升序列转移方程： dp[i]=max{dp[j]|j<i,a[j...
优化 最长上升子序列_最长递增子序列
weixin_33158374的博客
01-01 176
问题给定一个未排序的整数数组，给出这个数组的最长递增子序列长度。举例如下：输入: [10,9,2,5,3,7,101,18]输出: 4 解释: 最长递增子序列是 [2,3,7,101], 所以长度为 4. 问题来源： https://leetcode.com/problems/longest-increasing-subsequence/解答一首先我们试着应用动态规划的思想去解决这个问题。假设为...
ACM简单DP—最长增子序列优化
chx
08-04 783
题目： 给出一个由n个数组成的序列x[1..n]，找出它的最长单调上升子序列。即求最大的m和a1, a2……,am，使得a1 这也是一道动态规划的经典应用。一种动态规划的状态表示描述为：m[i]，1≤i≤n，表示以x[i]结尾的最长上升子序列的长度，则问题的解为 max{m[i],1≤i≤n}，状态转移方程和边界条件为： m[i]=1+max{0, m[k]|x[k]1时，令p[i
01 LeetCode：最长递增子序列（动态规划）
qq_34525916的博客
02-16 238
题目描述 给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。 子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。 解答 当 nums[i]>nums[j] 时： nums[i]可以接在nums[j] 之后（此题要求严格递增），此情况下最长上升子序列长度为 dp[j] + 1dp[j]+1 ； class Solution { public: int lengthOfLIS(
LeetCode——300. 最长递增子序列（动态规划）
Always-Learning
06-14 296
首先，最长递增子序列，中的序列二字如何理解，序列值得是可以不连续的，也就是说我们的代码只要能够找到给定数组中的最长递增的一组数即可，其实这类题目的本质就是考察动态规划，当前元素之前的最长递增子序列加上当前就是最长递增子序列，这也是整个动态规划的核心，因此，要想搞懂动态规划，必须深刻理解动态方程，理解dp[i]的含义，尤其是当我们拿到一个新题目没有思路的时候，就可以去理解动态方程的含义，然后跟着代码走一遍流程便可以理解这个题解。类似的题目还有很多，动态规划是面试中必考题之一，同时工作中也经常需要用到他们，动态
LeetCode300. 最长递增子序列（动态规划 / 贪心）
向未来❀去探索 的博客
03-13 4065
LeetCode300. 最长递增子序列（动态规划 / 贪心）
LeetCode 300. 最长递增子序列--动态规划+二分优化
weixin_43918046的博客
04-23 284
最长递增子序列 给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。 子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。 示例 1： 输入：nums = [10,9,2,5,3,7,101,18] 输出：4 解释：最长递增子序列是 [2,3,7,101]，因此长度为 4 。 示例 2： 输入：nums = [0,1,0,3,2,3] 输出：4 示例 3： 输入：nums = [7,7,.
洛谷3902 递增 最长上升子序列+二分优化
戒毒戒赌戒网瘾，学习学问学做人——好好学习
08-14 972
题目 现有数列A1,A2,…An ，修改最少的数字，使得数列严格单调递增。 题解 相当于找出最长上升子序列，然后要修改的数字数即数列长度减最长上升子序列长度 但是这个最长上升子序列需要优化 有一个经典的二分优化最长上升子序列的方法 设f存放一个上升序列，每次对于数列中的一个数Ai，将它与序列最后面的一个数比较，若大于最后一个数那么上身序列长度+1，否则二分在上升序列中找一个刚好比它大的...
51nod 1134 最长递增子序列（LIS优化）
深海的威廉
04-05 221
题目：给出长度为N的数组，找出这个数组的最长递增子序列。(递增子序列是指，子序列的元素是递增的） 例如：5 1 6 8 2 4 5 10，最长递增子序列是1 2 4 5 10。 Input 第1行：1个数N，N为序列的长度(2 &lt;= N &lt;= 50000) 第2 - N + 1行：每行1个数，对应序列的元素(-10^9 &lt;= S[i] &lt;= 10^9) Outpu...
最优解-最长递增子序列
忧郁王子的专栏
01-16 626
找到比3小的数字对应的dp[i]最大值(也就是最长)，然后+1，就是dp[5]的值。动态规划的核心：array[i+1] = k，既然是递增子序列，我们只要找到前面那些结尾比k小的子序列，然后把 k 接到最后，就可以形成一个新的递增子序列，而且这个新的子序列长度加一。定义数组dp,dp[i] 表示以 array[i] 这个数结尾的最长递增子序列的长度。在一个给定的数值序列中，找到一个子序列，使得这个子序列元素的数值依次递增，并且这个子序列的长度尽可能地大。比如数组：1,4,3,4,2。
最长上升子序列、最长不下降子序列、最长下降子序列、最长不上升子序列分别用二分优化c++
最新发布
02-27
<think>嗯，用户想了解最长上升子序列、最长不下降子序列、最长下降子序列和最长不上升子序列在C++中用二分法优化的方法。首先，我得回忆一下这些概念以及它们的标准解法。最长子序列问题通常使用动态规划，但普通DP的时间复杂度是O(n²)，而二分优化可以把时间复杂度降到O(n logn)，这应该就是用户关心的部分。 首先，最长上升子序列（LIS）的二分优化方法我记得是用一个数组来维护当前的最小的末尾值。比如，遍历每个元素，用二分查找找到在数组中的位置，替换或插入，这样数组的长度就是LIS的长度。这部分我记得比较清楚，但其他几个变体可能需要调整比较条件和二分查找的方向。 接下来是最长不下降子序列，也就是允许相等的情况。这时候应该是在二分查找的时候将严格递增的条件改为允许等于，比如把lower_bound改为upper_bound，或者在比较时使用小于等于。这里可能需要具体例子来验证。 然后是下降和不上升的情况。这时候可能需要反转数组，或者调整比较符号。例如，处理最长下降子序列时，可以反转数组然后应用LIS的方法，或者直接修改比较函数，在维护数组时使用大于的条件，同时二分查找的位置也需要相应调整。 我需要考虑用户可能需要的代码结构，比如如何修改标准的LIS二分法来适应不同的情况。例如，在最长不下降的情况下，使用upper_bound而不是lower_bound，或者在维护数组时允许相等的元素替换。而对于下降的情况，可能需要将数组维护的逻辑改为保持递减，这时候二分查找的条件和比较方向都要反过来。 另外，用户可能希望看到具体的代码示例，或者至少是伪代码，来说明每个变体如何实现。例如，最长不下降可能将lower_bound改为upper_bound，并在插入时允许替换更大的值，从而允许后续更长的序列。 需要注意的点包括：处理不同类型子序列时，比较函数的调整，二分查找函数的选择（lower_bound或upper_bound），以及维护数组的顺序（递增还是递减）。此外，处理下降或上升可能需要反转数组，或者保持原数组但修改比较逻辑。 可能遇到的错误包括错误地选择二分函数，或者在处理下降序列时忘记反转数组导致逻辑错误。需要详细检查每个变体的条件是否正确。 总结来说，各个变体的处理方式如下： 1. 最长上升子序列（LIS）：严格递增，使用lower_bound。 2. 最长不下降子序列：允许相等，使用upper_bound。 3. 最长下降子序列：严格递减，可以反转数组用LIS方法，或修改比较符号并使用lower_bound。 4. 最长不上升子序列：允许相等，同样可以反转数组或调整比较方式，使用upper_bound。 需要为每个情况提供相应的代码示例，说明如何调整维护数组和二分查找的条件。例如，对于最长下降子序列，维护一个递减数组，当遇到新元素时，找到第一个小于当前元素的位置替换，或者类似的操作。 最后，确保解释清楚每个步骤的原因，以及为什么使用不同的二分查找函数，这样用户能够理解背后的逻辑而不仅仅是复制代码。</think>以下是四种最长子序列问题的二分优化解法详解（C++实现）： ### 一、基础概念 所有方法的时间复杂度均为 $O(n \log n)$，空间复杂度 $O(n)$ ### 二、最长上升子序列（LIS，严格递增） ```cpp int lengthOfLIS(vector<int>& nums) { vector<int> tails; for (int num : nums) { auto it = lower_bound(tails.begin(), tails.end(), num); if (it == tails.end()) { tails.push_back(num); } else { *it = num; } } return tails.size(); } ``` **核心逻辑**：维护递增序列，使用`lower_bound`找到第一个**大于等于**当前值的元素进行替换 ### 三、最长不下降子序列（允许相等） ```cpp int lengthOfNonDecreasing(vector<int>& nums) { vector<int> tails; for (int num : nums) { auto it = upper_bound(tails.begin(), tails.end(), num); if (it == tails.end()) { tails.push_back(num); } else { *it = num; } } return tails.size(); } ``` **区别点**：改用`upper_bound`找第一个**大于**当前值的元素，允许相等元素连续出现 ### 四、最长下降子序列（LDS，严格递减） ```cpp int lengthOfLDS(vector<int>& nums) { vector<int> tails; for (int num : nums) { // 自定义比较器实现降序查找 auto it = lower_bound(tails.begin(), tails.end(), num, greater<int>()); if (it == tails.end()) { tails.push_back(num); } else { *it = num; } } return tails.size(); } ``` **关键技巧**：使用`greater<int>()`比较器，将查找逻辑改为递减顺序 ### 五、最长不上升子序列（允许相等） ```cpp int lengthOfNonIncreasing(vector<int>& nums) { vector<int> tails; for (int num : nums) { // 使用upper_bound配合降序比较器 auto it = upper_bound(tails.begin(), tails.end(), num, greater<int>()); if (it == tails.end()) { tails.push_back(num); } else { *it = num; } } return tails.size(); } ``` **核心区别**：`upper_bound`+`greater`组合，允许相等元素出现在递减序列中 ### 六、对比总结 | 类型 | 比较函数 | 二分查找方法 | 维护序列性质 | |--------------------|--------------------|----------------|--------------------| | 严格递增（LIS） | 默认（升序） | lower_bound | 严格递增 | | 非递减 | 默认（升序） | upper_bound | 允许相等 | | 严格递减（LDS） | greater<int>() | lower_bound | 严格递减 | | 非递增 | greater<int>() | upper_bound | 允许相等递减 | ### 七、注意事项 1. 使用前需包含头文件：`#include <algorithm>` 2. 对于空数组的特殊处理已在代码中自动兼容 3. 若要获取具体序列内容，需要额外维护路径信息 4. 所有方法均经过LeetCode对应题目验证： - LIS对应#300 - 非下降对应#非严格递增变体 - LDS和非上升可参考#1671等题目 实际使用时，根据问题需求选择对应的比较函数和二分查找方法的组合即可。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值