最长上升子序列vs最长非递减子序列

上面的这两个都可以直接用dp来写,但是dp的话复杂度是 n 2 n^2 n2,复杂度还是太大了

先从最长上升子序列说起

二分+贪心

我们可以维护一个到 a [ i ] a[i] a[i]的最长上升子序列,每次遇到一个新的数 x x x 就在刚刚的序列里面二分查找第一个大于等于 x x x 的位置,这里直接二分就行,如果序列的最大一个元素还是小于 x x x,那么我们的x就直接放到序列的最后面

[ 2 , 4 , 7 ] [2 , 4, 7] [2,4,7] 当前 x = 8, 那么8就可以直接插入序列的末尾就可以维护一个更长的上升序列

[ 2 , 4 , 7 ] [2 , 4, 7] [2,4,7] 当前 x = 5, 那么5应该插入到 7 的位置,这样可以维护一个长度相等,但是一个更优的序列

代码如下:

class Solution:
    def lengthOfLIS(self, nums: List[int]) -> int:
        g = []
        for x in nums:
            j = bisect_left(g,x)
            if j == len(g):
                g.append(x)
            else:
                g[j] = x
        return len(g)

如果是最长非递减子序列呢,这个就要求我们维护的序列中可以存在相同的元素
改进也很简单

# 上面的代码只用修改 bisect_left
# 改成 
j = bisect_right(g,x)

万能法:线段树或树状数组

我们可以直接定义 d p [ i ] dp[i] dp[i] 为以 a [ i ] a[i] a[i] 结尾的序列的最大长度,那么应该怎么转换呢

d p [ i ] = m a x ( d p [ j ] ) + 1 , j < i a [ j ] < a [ i ] dp[i] = max(dp[j])+1,j<i a[j]<a[i] dp[i]=max(dp[j])+1,j<ia[j]<a[i]
我们怎么找到所有索引在 i i i之前,且 a [ j ] < a [ i ] a[j] < a[i] a[j]<a[i] d p [ j ] dp[j] dp[j] 最大值呢

我们用到权值线段树,不用数组 a [ i ] a[i] a[i] 的下标索引 i i i 作为线段树的插入索引,而是用 a [ i ] a[i] a[i]的值作为索引, d p [ i ] dp[i] dp[i] 作为线段树中我们要维护的值,我们每次只要查询 [ 1 , a [ i ] ] [1,a[i] ] [1,a[i]] 之间的最大值就可以得到满足的最大的 d p [ j ] dp[j] dp[j],(注意,最长上升子序列是 [ 1 , a [ i ] − 1 ] [1,a[i]-1] [1,a[i]1],最长非递减子序列是 [ 1 , a [ i ] ] [1,a[i]] [1,a[i]]

注意一下update函数的更新细节

         if l==r:
             self.t[o] = max(self.t[o],x)  # 可能会重复更新
<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
发出的红包

打赏作者

wniuniu_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值