求最长上升子序列

求最长上升子序列

笔者在湖大参加WPS笔试时曾碰这么一道问题,当时没有想出好的办法,回学校后赶紧查了资料,现在我用自己的语言描述一下。

问题描述

一个数的序列bi,当b1 < b2 < … < bS的时候,我们称这个序列是上升的。对于给定的一个序列(a1, a2, …, aN),我们可以得到一些上升的子序列(ai1, ai2, …, aiK),这里1 <= i1 < i2 < … < iK <= N。比如,对于序列(1, 7, 3, 5, 9, 4, 8),有它的一些上升子序列,如(1, 7), (3, 4, 8)等等。这些子序列中最长的长度是4,比如子序列(1, 3, 5, 8).

输入:任意长度的数组

输出:该数组中最长子序列的长度

案例:

输入:[1, 7, 3, 5, 9, 4, 8]

输出:[1, 3, 5, 8]

解题思路

有经验的同学一定可以看出来,这就是一道动态规划的题目,那么我们就只需要找出它的子问题。这道题的子问题我们可以设为“求以ak(k=1, 2, 3…N)为终点的最长上升子序列的长度“,注意,这里的子问题我们不是设为”求到ak(k=1, 2, 3…N)为止的a1,a2…ak之间数组的最长上升子序列的长度“。

转移方程也就随之而出了

①MaxLen (1) = 1 //这里的MaxLen(n)表示以数组下标n为终点的最长上升子序列的长度

②MaxLen (k) = Max { MaxLen (i):1< i< k 且 ai < ak且 k≠1 } + 1

当然,②也有另一种表述MaxLen (k) = Max { MaxLen (i)+1:1< i < k 且 ai < ak且 k≠1 },本质上是一样的。使用转移方程之前,要初始化 MaxLen(n) = 1

实现代码

//java
class MaxSubLenTool{
public static int getMaxSubLen(int[]nums){
    if(nums == null || nums.length <= 0)
        return -1;
    if(nums.length == 1)
        return 1;
    int seqlen[] = new int[nums.length];//对应下标所在数字为升序终点的最大长度
    for(int i = 0 ;i < nums.length ;i ++)
        seqlen[i] = 1;
    int maxLen = 1;
    for(int i = 1 ; i < nums.length ; i ++){
        for(int j = i-1 ; j >= 0; j --){
            if(nums[j] < nums[i] && seqlen[j]+1 > seqlen[i]){
                System.out.println("nums[j] = "+nums[j]+",nums[i] = "+nums[i]);
                seqlen[i] = seqlen[j] + 1;
            }
        }
        if(seqlen[i] > maxLen)
            maxLen = seqlen[i];
    }
    for(int key:seqlen)
        System.out.println(key);
    System.out.println("res");
    return maxLen;
}

}

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

余额充值