最长上升子序列两种求法

最新推荐文章于 2021-01-30 00:33:35 发布
原创 最新推荐文章于 2021-01-30 00:33:35 发布 · 324 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了两种求解最长上升子序列的有效方法：一种利用set的lower_bound()函数找到合适位置进行插入；另一种采用队列结合二分查找实现，通过替换队列中的元素达到目的。

方法1.

插入序列过程中，找比自己大的元素中最小的插入到其后面，再将那个数删除。最后求剩下元素个数即最长上升子序列。（set的lower_bound()函数应用）。

方法2.

队列，插入序列过程中，如果比队头元素小就替换队头元素，如果比队尾元素大就插入到队尾后面，其他情况二分查找与他相差最小的数的，将其替换。

最长上升子序列（动态规划）
syc_36的博客
03-18 3543
子序列 所谓的子序列就是在原来序列中找出一部分组成的序列。 与子段不同，不需要连续的某一段，但是要保持原序列的先后顺序 最长上升子序列 在子序列的基础上，后一项大于前一项。 【题目描述...
最长上升子序列
热门推荐
wangkechuang的专栏
09-06 1万+
最长上升子序列问题是各类信息学竞赛中的常见题型，也常常用来做介绍动态规划算法的引例，笔者接下来将会对POJ上出现过的这类题目做一个总结，并介绍解决LIS问题的两个常用 算法(n^2)和(nlogn). 问题描述:给出一个序列a1,a2,a3,a4,a5,a6,a7....an,求它的一个子序列（设为s1,s2,...sn），使得这个子序列满足这样的性质，s1 例如有一个序列:1  7  3
最长上升子序列 DP+贪心算法
weixin_30551963的博客
10-10 289
最初没有多想，直接用最基本的DP写的代码，本想水过，可是测试数据超时。。。 DP O（n*n）算法代码： #include<iostream>using namespace std;int main(){ const int SIZE = 1005; int dp[SIZE]; int arr[SIZE]; int n; while(cin>...
求最长上升子序列
我要吃熊猫
07-14 583
LIS
最长上升子序列的两种求法 POJ 2533
zamaochick的博客
03-23 501
最长上升子序列一共有两种求法： 1.dp，也可以说的纯暴力吧。 dp[i]表示以a[i]为结尾的最长上升子序列的长度。 所以只要满足j<i且a[j]<a[i]，则一定满足dp[j]=max(dp[j],dp[i]+1); 复杂度为n^2; 2.是在上述方法的优化，建一个dp数组。 dp[i]表示长度为i的上升子序列中末尾元素的最小值。 因为dp数组一定是有序的，这样每次插...
最长上升子序列最长上升子序列PDF
03-16
动态规划是解决最长上升子序列问题的一种有效方式。在动态规划的方法中，我们通常定义一个dp数组来记录每个位置结尾的最长上升子序列的长度。dp[i]的值表示考虑到第i个元素为止，能够构成的最长上升子序列的长度。...
算法设计-最长上升子序列问题
最新发布
03-16
最长上升子序列问题（Longest Increasing Subsequence, 简称LIS），是计算机科学领域中一种经典的动态规划问题，主要用来求解一组数中的最长上升子序列的长度。所谓“上升子序列”，指的是序列中任意两个相邻的数...
leetcode-master-最长上升子序列
03-16
这种方法被称作Patience Sorting算法，是一种基于分而治之的思想，通过维护一堆有序的牌来模拟整个过程，能够高效地找到最长上升子序列。 在实际应用中，最长上升子序列问题可以用于各种场景，例如在生物信息学中，...
Algorithms-最长上升子序列
03-16
最长上升子序列（Longest Increasing Subsequence，简称LIS）是一个经典的计算机科学问题，属于动态规划领域的范畴。在这个问题中，给定一个未排序的整数数组，我们要求找出数组中最长的上升子序列。一个子序列是指...
最长上升子序列(LIS)
Wuko666的博客
01-30 3526
题目链接 dp数组：dp[maxn]；存储数组: a[N]; 求一个长度为N的上升子序列的递推公式： 1.dp[i] : 定义为以a[i]为结尾的(数组下标从 0 开始)序列最大上升子序列的值 2.以a[i]为结尾的最大上升子序列为： （1）a[i] 本身 （2）j < i && a[j]<a[i]以a[j]为结尾的上升子序列,末尾追加a[i]的子序列 由此得出递推公式 dp[i] = max(1,dp[j] +1 | （ j < i &&amp
动态规划——求最长上升子序列长度
靡不有初鲜克有终
02-28 794
/* *问题描述：求最长上升子序列长度 */ #include #include #include using namespace std; const int MAXN = 1010; int a[MAXN];//存储输入的数据 int maxLen[MAXN];//存储从开始到每一个数据中最长上升子序列长度 int main() { int N; cin>>N;
LIS 求最长上升子序列长度
BlackJack
03-07 461
求最长上升子序列长度 #include #include using namespace std; const int MAXN=5001; int s[MAXN]; int main(int argc, char *argv[]) { int n,i,x,l,r,mid; int top=0; s[0]=-1; sca
怎么求最长上升子序列
02-19
<think>嗯，用户问的是如何求最长上升子序列。这个问题我得先回忆一下相关的算法知识。最长上升子序列，也就是Longest Increasing Subsequence，简称LIS。这个问题是一个经典的动态规划问题，对吧？ 首先，我得明确问题。最长上升子序列的定义是在一个无序的整数序列中，找到最长的一个子序列，这个子序列中的元素是严格递增的，或者说非递减的，这要看题目具体要求。比如，假设序列是[10,9,2,5,3,7,101,18]，那么LIS是[2,5,7,101]，长度是4。不过有时候可能允许非严格递增，比如允许相等的情况，这里可能需要根据题目调整。 那怎么求呢？常见的解法有两种，一种是动态规划，时间复杂度O(n²)，另一种是贪心加二分查找，时间复杂度O(n log n)。用户可能想知道这两种方法，或者其中一种更优的方法？ 首先，动态规划的方法比较直观。动态规划的核心是定义状态和状态转移方程。对于每个元素i，dp[i]表示以第i个元素结尾的最长上升子序列的长度。那么，对于每个i，我们需要遍历前面的所有元素j（j < i），如果nums[i] > nums[j]，那么dp[i] = max(dp[i], dp[j]+1)。最后，最大的dp值就是结果。 比如，例子中的数组，动态规划的过程是怎样的呢？比如数组是[10,9,2,5,3,7,101,18]。初始化dp数组全为1，因为每个元素自身可以作为一个子序列。然后从第二个元素开始，比如第二个元素是9，比前面的10小，所以dp[1]还是1。第三个元素是2，同样比前面的都小，所以dp[2]=1。第四个元素是5，比前面的2大，所以dp[3] = dp[2]+1=2。依次类推，每个元素都和之前的所有元素比较，并更新dp值。这样时间复杂度是O(n²)，对于小规模的n没问题，但数据量大时可能不够高效。 那更高效的方法呢？就是贪心加二分。这个方法的核心是维护一个数组tails，其中tails[i]表示长度为i+1的子序列的最小末尾元素。例如，如果有多个长度为2的递增子序列，比如[2,3]、[2,5]，那么tails[1]就是3，因为3比5小，这样后面更容易接上更大的数。这样维护的tails数组是递增的，所以可以用二分查找来优化。 具体步骤是，遍历数组中的每个元素，用二分法在tails中找到第一个大于等于当前元素的位置，然后替换它。如果当前元素比tails中所有元素都大，就添加到tails末尾。这样，最后tails的长度就是LIS的长度。但需要注意的是，这种方法得到的tails数组并不一定是真实的LIS，但长度是正确的。 比如同样的例子，初始tails为空。处理10，tails变为[10]。处理9，找到第一个>=9的位置是0，替换为9，tails变成[9]。处理2，替换第一个位置，tails变为[2]。处理5，比2大，添加到末尾，tails是[2,5]。处理3，找到比3大的第一个元素是5的位置，替换为3，tails变为[2,3]。处理7，添加到末尾，tails是[2,3,7]。处理101，添加到末尾，tails变成[2,3,7,101]。处理18，找到第一个大于18的位置是3，替换101为18，tails是[2,3,7,18]。所以长度是4，正确。 这时候，时间复杂度是O(n log n)，因为每个元素都需要一次二分查找，而二分的时间是O(log n)。 那如何实现这两种方法呢？动态规划比较简单，先初始化一个dp数组，然后双重循环。而贪心加二分则需要维护tails数组，并且使用bisect模块或者自己实现二分。 用户可能需要具体的代码示例，或者步骤解释。比如动态规划： def length_of_LIS(nums): if not nums: return 0 dp = [1] * len(nums) for i in range(len(nums)): for j in range(i): if nums[i] > nums[j]: dp[i] = max(dp[i], dp[j] + 1) return max(dp) 而贪心加二分： import bisect def length_of_LIS(nums): tails = [] for num in nums: idx = bisect.bisect_left(tails, num) if idx == len(tails): tails.append(num) else: tails[idx] = num return len(tails) 这样，tails数组的长度就是结果。需要注意的是，bisect_left找的是插入的位置，如果是替换的话，可以保持tails的最小末尾。 用户可能还会问这两种方法的区别，或者为什么贪心方法有效。这时候可能需要解释tails数组的性质，即其维护的是各个长度的最小末尾，这样后面添加更大的数更容易形成更长的序列。 总结来说，两种方法各有优劣，动态规划容易理解但效率低，贪心加二分效率高但实现需要二分查找。根据实际情况选择合适的方法。</think>最长上升子序列（Longest Increasing Subsequence, LIS）是指在一个无序序列中找到一个最长的子序列，使得该子序列中的元素严格递增（或非递减，根据题目要求）。以下是两种常用解法： --- ### **方法一：动态规划（时间复杂度 O(n²)）** **思路**： 1. 定义 `dp[i]` 表示以 `nums[i]` 结尾的最长上升子序列的长度。 2. 初始化所有 `dp[i] = 1`（每个元素自身是一个长度为1的子序列）。 3. 对于每个 `i`，遍历 `j`（从 `0` 到 `i-1`）： - 若 `nums[i] > nums[j]`，则 `dp[i] = max(dp[i], dp[j] + 1)`。 4. 最终结果为 `max(dp)`。 **代码示例**： ```python def length_of_LIS(nums): if not nums: return 0 dp = [1] * len(nums) for i in range(len(nums)): for j in range(i): if nums[i] > nums[j]: dp[i] = max(dp[i], dp[j] + 1) return max(dp) ``` --- ### **方法二：贪心 + 二分查找（时间复杂度 O(n log n)）** **思路**： 1. 维护一个数组 `tails`，其中 `tails[i]` 表示长度为 `i+1` 的上升子序列的最小末尾元素。 2. 遍历每个元素 `num`： - 若 `num` 大于 `tails` 的最后一个元素，直接添加到末尾。 - 否则，用二分查找找到 `tails` 中第一个大于等于 `num` 的位置，将其替换为 `num`。 3. 最终 `tails` 的长度即为 LIS 的长度。 **代码示例**： ```python import bisect def length_of_LIS(nums): tails = [] for num in nums: idx = bisect.bisect_left(tails, num) # 找到插入位置 if idx == len(tails): tails.append(num) else: tails[idx] = num return len(tails) ``` --- ### **关键区别** - **动态规划**：直观但效率较低，适用于小规模数据。 - **贪心 + 二分**：高效，适用于大规模数据，但需理解 `tails` 数组的维护逻辑。 **示例**： 对于 `nums = [10, 9, 2, 5, 3, 7, 101, 18]`，两种方法均会返回最长上升子序列长度 **4**（如 `[2, 5, 7, 101]` 或 `[2, 3, 7, 18]`）。 选择方法时，可根据数据规模和对性能的要求进行权衡。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值