最长上升子序列两种求法

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

方法1.

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

方法2.

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

<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、付费专栏及课程。

余额充值