LeetCode 5394.找到和最大的长度为K的子序列

最新推荐文章于 2025-04-14 05:30:00 发布

void丿

最新推荐文章于 2025-04-14 05:30:00 发布

阅读量510

点赞数

CC 4.0 BY-SA版权

分类专栏：数据结构与算法文章标签： leetcode 算法深度优先

本文链接：https://blog.youkuaiyun.com/weixin_43897770/article/details/121896490

给定整数数组nums和整数k，找出一个长度为k且和最大的子序列。需要先对数组排序，记录每个元素的下标，然后选择前k个最大值，再按原下标顺序排列，以获取最大和子序列。

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

题目：

给你一个整数数组 nums 和一个整数 k 。你需要找到 nums 中长度为 k 的子序列，且这个子序列的和最大。

请你返回任意一个长度为 k 的整数子序列。

子序列定义为从一个数组里删除一些元素后，不改变剩下元素的顺序得到的数组。

被自己菜到了，周赛的时候想了半天才整出来最开始往递归dfs的思路走，但实际就是求最大和的不连续子序列，于是只需要先按值排序，并记录下标，之后取出前k个值后再按下标升序排序得到原先的相对位置，即可获得答案。

class Solution {
   
   
    public int[] maxSubsequence(int[] nums, int k) {
   
   
        int len = nums.length;
        int[][] tmp = new int[len]

最低0.47元/天解锁文章

200万优质内容无限畅学

确定要放弃本次机会？

福利倒计时

: :

立减 ¥

普通VIP年卡可用

立即使用

void丿

关注关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
分享

复制链接

分享到 QQ

分享到新浪微博

扫一扫
举报

举报

专栏目录

Leetcode 2099. 找到和最大的长度为 K 的子序列(已解决)

我不是码农的博客~~~

06-05

325

给你一个整数数组 digits ，其中每个元素是一个数字（0 - 9）。数组中可能存在重复元素。你需要找出所有满足下述条件且互不相同的整数：该整数由 digits 中的三个元素按任意顺序依次连接组成。该整数不含前导零该整数是一个偶数例如，给定的 digits 是 [1, 2, 3] ，整数 132 和 312 满足上面列出的全部条件。将找出的所有互不相同的整数按递增顺序排列，并以数组形式返回。示例 1：示例 2：示例 3：提示：Code:...

leetcode 2461.长度为k子数组的最大和

LS_Ai的博客

08-24

939

通过移动指针来改变窗口的大小和位置，在窗口移动的过程中，根据问题的需求进行特定的计算和处理。因为 15 是满足全部条件的所有子数组中的最大子数组和，所以返回 15。- [2,9,9] 不满足全部条件，因为元素 9 出现重复。- [9,9,9] 不满足全部条件，因为元素 9 出现重复。- [4,4,4] 不满足全部条件，因为元素 4 出现重复。- [1,5,4] 满足全部条件，和为 10。- [5,4,2] 满足全部条件，和为 11。- [4,2,9] 满足全部条件，和为 15。

参与评论您还未登录，请先登录后发表或查看评论

序列元素和是k的倍数的最大子串长度

奋斗豆角的博客

08-31

1055

给一个定长的元素集，求子串中元素和是K的倍数的最大子串长度。输入第一行数序列长度，输入第二行是序列各元素值，第三行是整数K 输出序列元素子串和是K倍数的最大长度

找到和最大的长度为K的子序列

kku101xyz的博客

01-07

392

Corux原创.

2099 找到和最大的长度为 K 的子序列

weixin_44171872的博客

01-23

643

题目描述：给你一个整数数组 nums 和一个整数 k 。你需要找到 nums 中长度为 k 的 子序列 ，且这个子序列的和最大。请你返回任意一个长度为 k 的整数子序列。 子序列 定义为从一个数组里删除一些元素后，不改变剩下元素的顺序得到的数组。示例 1：输入：nums = [2,1,3,3], k = 2 输出：[3,3] 解释： 子序列有最大和：3 + 3 = 6 。示例 2：输入：nums = [-1,-2,3,4], k = 3 输出：[-1,3,4] 解释： 子序列有最大和：-

找到和最大的长度为K的子序列（修改版）

kku101xyz的博客

05-11

412

2099. 找到和最大的长度为 K 的子序列 - 力扣（LeetCode）目录说明思路代码说明和上一篇答案的主要不同是自己写了个pair提高了运行速度，代码核心部分并未改变。首先放上运行结果：思路 1. 利用pair，把元素值和其在原数组中的位置关联在一起. 2. 首先根据元素值val来构造最小堆，利用最小堆找出最大的k个元素； 3. 然后根据位置下标idx来调整最小堆； 4. 最后依次从堆顶取出元素值，放入最终的数组ans中. 代码 ..

【LeetCode】找到和最大的长度为 K 的子序列 java

学习，分享，总结。

01-04

972

题目给你一个整数数组 nums 和一个整数 k 。你需要找到 nums 中长度为 k 的 子序列 ，且这个子序列的和最大。请你返回任意一个长度为 k 的整数子序列。 子序列 定义为从一个数组里删除一些元素后，不改变剩下元素的顺序得到的数组。示例 1：输入：nums = [2,1,3,3], k = 2 输出：[3,3] 解释： 子序列有最大和：3 + 3 = 6 。示例 2：输入：nums = [-1,-2,3,4], k = 3 输出：[-1,3,4] 解释： 子序列有最大和：-1 +

python-leetcode-2099. 找到和最大的长度为 K 的子序列

最新发布

Lucy_wzw的博客

04-14

870

子序列是从原数组中删除一些元素（但保持剩下元素的顺序不变），所以我们不需要选取连续的元素，但必须保留元素的相对顺序。

LeetCode300. 最长递增子序列

Chang的博客

10-25

541

description 给定一个包括 n 个整数的数组 nums 和一个目标值 target。找出 nums 中的三个整数，使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。示例：输入：nums = [-1,2,1,-4], target = 1 输出：2 解释：与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。分析看到这种查找值类型的题目，而且数组nums无序，首先应当想到先给数组排个序，便于后续的各种操作。最容易想到的方法可能是暴力

力扣周赛 5934题找到和最大的长度为 K 的子序列 打卡

getinobacar的博客

12-12

461

5934. 找到和最大的长度为 K 的子序列 给你一个整数数组nums和一个整数k。你需要找到nums中长度为 k的 子序列，且这个子序列的和最大。请你返回任意一个长度为k的整数子序列。 子序列定义为从一个数组里删除一些元素后，不改变剩下元素的顺序得到的数组。示例一：输入：nums = [2,1,3,3], k = 2 输出：[3,3] 解释： 子序列有最大和：3 + 3 = 6 。示例二：输入：nums = [-1,-2,3,4], k = 3 输...

leetcode2099.找到和最大的长度为k的子序列（简单，周赛）

zhangjiaji111的博客

12-13

598

本质：找前k大值。难点：如何下标递增返回ans？解决方案：得到前k大值后，把出现的元素以及出现的个数放在hash中，然后遍历一遍数组，每次- -即可得到。 class Solution { public: vector<int> maxSubsequence(vector<int>& nums, int k) { vector<int> ans; priority_queue<pair<int, int&...

Leetcode-2099. 找到和最大的长度为 K 的子序列

道纪书生的博客

09-07

609

Leetcode-2099. 找到和最大的长度为 K 的子序列

【LeetCode】2099. 找到和最大的长度为 K 的子序列

微信公众号: 后端码匠

12-24

555

给你一个整数数组 nums 和一个整数 k。你需要找到 nums 中长度为 k 的 子序列 ，且这个子序列的和最大。请你返回任意一个长度为 k 的整数子序列。子序列 定义为从一个数组里删除一些元素后，不改变剩下元素的顺序得到的数组。

2099. 找到和最大的长度为 K 的子序列

qq_44658941的博客

03-26

293

2099. 找到和最大的长度为 K 的子序列 解题经验: 1.求k个数问题，就将k个数放到堆中 2.本题巧妙在用int[]记录了键和值，比map好的地方在于,可以存储重复的键 map ~~ int[][] -->二维数组优点：可以存重复的键 public int[] maxSubsequence(int[] nums, int k) { if (nums == null || nums.length == 0) return null; else

算法--找到和最大的长度为 K 的子序列(Kotlin)

男儿不展风云志，空有天生八尺躯

06-22

631

输入：nums = [-1,-2,3,4], k = 3 输出：[-1,3,4] 解释： 子序列有最大和：-1 + 3 + 4 = 6 。示例 3：输入：nums = [3,4,3,3], k = 2 输出：[3,4] 解释： 子序列有最大和：3 + 4 = 7 。另一个可行的子序列为 [4, 3] 。提示：1 ...

2022-5-21[堆] 找到和最大的长度为 K 的子序列, 最大平均通过率, 满足不等式的最大值, 删除元素后和的最小差值

weixin_43791477的博客

05-21

378

2022-5-21[堆] 找到和最大的长度为 K 的子序列, 最大平均通过率, 满足不等式的最大值, 删除元素后和的最小差值

长度为k的子序列

qq_41056867的博客

04-12

417

长度为k的子序列中，和为偶数的个数。 import java.util.*; public class Main { public static void main(String[] args){ Scanner in=new Scanner(System.in); int t=in.nextInt(); for(int i=0;i<t;i++){ int n=in.nextInt(); int k

8 找到和最大的长度为 K 的子序列

Ultravioletrays的博客

07-03

680

8 找到和最大的长度为 K 的子序列作者: Turbo时间限制: 1S章节: 课程设计问题描述 :给你一个整数数组 nums 和一个整数 k 。你需要找到 nums 中长度为 k 的子序列 ，且这个子序列的和最大。请你返回任意一个长度为 k 的整数子序列。子序列 定义为从一个数组里删除一些元素后，不改变剩下元素的顺序得到的数组。示例 1：输入：42 1 3 32输出：3 3解释：子序列有最大和：3 + 3 = 6 。示例 2：输入：4-1 -2 3 43输出：-1 3 4解释：子序列有最大和：-1

字串或子序列和为k的倍数的最大长度

小白成长之路

08-02

1444

子序列为k的倍数的最大长度链接：https://ac.nowcoder.com/acm/problem/15613 来源：牛客网给一个数组 a，长度为 n，若某个子序列中的和为 K 的倍数，那么这个序列被称为“K 序列”。现在要你对数组 a 求出最长的子序列的长度，满足这个序列是 K 序列。解法1： 01背包要或者不要 dp[j]表示余数为j的最大长度，我们可以把所有的数转换为k...

找到和最大的长度为k的子序列力扣

03-30

<think>好的，用户现在想解决LeetCode上关于寻找长度为k且和最大的子序列的问题。首先，我需要回忆相关的题目和解法。根据用户提供的引用，特别是引用[2]和[5]，LeetCode 2099题就是这个问题。用户提到需要算法或解题思路，所以我要先整理已有的信息。首先，子序列和子数组不同，子序列不要求连续，但顺序必须保持。题目要求长度为k，且和最大。常见的思路可能是先排序然后取最大的k个数，但这样会破坏顺序，导致得到的子序列顺序与原数组不符。比如，如果数组是[3,1,4,2]，k=2，排序后最大的两个数是4和3，但原数组中4在3之后，所以正确的子序列应该是[3,4]，但直接排序选最大的两个可能得到[4,3]，顺序不对。因此，直接排序不行，需要考虑其他方法。引用[5]中提到了选择排序的方法，每次选出剩余元素中的最大值，并记录其索引，然后将该位置置为None，避免重复选择。最后根据记录的索引排序，得到正确顺序的子序列。这种方法的时间复杂度是O(nk)，当k较小时比较高效。但若k接近n，则可能达到O(n²)，不过题目可能数据规模不大，可以接受。另一种方法是使用堆（优先队列），如引用[2]提到的堆解法。具体来说，可以维护一个大小为k的最大堆，或者使用堆来快速找到最大的k个元素及其索引。不过需要注意保持元素的顺序。可能的步骤是：遍历数组，将元素和索引存入堆中，按值从大到小排序。取出前k个元素后，根据索引排序，得到正确顺序的子序列。这种方法的时间复杂度是O(n log n)，因为堆的插入操作是O(log n)，而最后对k个元素排序是O(k log k)。对于较大的n，这种方法可能更优。然后，我需要考虑动态规划是否有适用的可能，但根据问题特点，子序列需要保持顺序，并且长度固定为k，和最大。动态规划的状态可能设计为dp[i][j]，表示前i个元素中长度为j的子序列的最大和。状态转移方程需要考虑是否选择当前元素。但这样的动态规划时间复杂度是O(nk)，可能和选择排序方法相当，但实现起来稍微复杂。不过引用中没有提到动态规划解法，可能更推荐堆或选择方法。现在需要比较这两种方法的优劣。堆方法的时间复杂度更低，尤其是当k较大时。而选择排序方法在k较小时更优，实现简单。根据题目给出的示例代码，引用[5]中的解法就是选择排序的思路，每次选最大的元素，记录索引，最后按索引排序输出。这可能更适合快速实现，尤其是在编程比赛中。另外，还需要注意重复元素的情况。例如，如果有多个相同的最大值，需要正确选择它们的索引，以保持子序列的顺序。例如数组[5,3,5,2]，k=2，应选择第一个5和第二个5，子序列是[5,5]，但它们的索引分别是0和2，所以最终输出应为[5,5]。总结可能的解题步骤： 1. 遍历数组，找到最大的k个元素，并记录它们的值和原始索引。 2. 根据记录的索引进行排序，确保子序列的顺序与原数组一致。 3. 提取对应的值形成结果子序列。在实现时，需要注意如何处理元素的选择，确保每次选的是当前剩余元素中的最大值，同时记录索引。引用[5]中的代码通过将已选元素置为None来避免重复选择，这可能有效，但修改原数组是否允许需要考虑题目要求。如果题目不允许修改原数组，可能需要复制数组或使用其他方式标记已选元素。另外，堆方法如何实现？例如，可以将所有元素和索引一起存入堆中，按值从大到小排序。取出前k个元素后，根据索引排序，然后输出对应的值。这样可以避免修改原数组，并且时间复杂度为O(n + k log k)，因为堆化需要O(n)时间（如果使用heapq.nlargest），然后对k个元素排序需要O(k log k)。这可能更高效，尤其是当n较大时。因此，用户的问题需要给出这两种可能的解法，并比较它们的优缺点。同时，引用中的示例代码使用的是选择排序的方法，而引用[2]提到了堆解法，所以需要详细说明这两种方法，并给出代码示例。另外，需要注意子序列和子数组的区别，确保解答中明确说明这一点。例如，子序列不需要连续，但顺序必须保持，而子数组是连续的。最后，根据用户提供的引用，特别是引用[2]和[5]，需要将这两种方法整合到回答中，并正确引用对应的参考资料。</think>### LeetCode 2099. 找到和最大的长度为 K 的子序列 #### 问题分析题目要求从整数数组 $nums$ 中选出长度为 $k$ 的子序列，使得其和为最大，且保持元素的原始顺序[^2]。由于子序列不要求连续，但必须保持顺序，直接排序会破坏索引关系，因此需要结合数值大小和索引顺序进行选择。 --- ### 核心解法 #### 1. 选择排序法（贪心思想） **思路**：每次选择当前剩余元素中的最大值，记录其索引，并将该位置标记为已选（例如置为 `None`），重复此过程直到选满 $k$ 个元素。最后根据索引顺序输出结果。 - **时间复杂度**：$O(nk)$，适用于 $k$ 较小的情况。 - **空间复杂度**：$O(1)$（原地修改数组）或 $O(n)$（使用辅助数组）。 ```python def maxSubsequence(nums, k): ans = [] for _ in range(k): max_val, max_idx = -float('inf'), -1 for idx, val in enumerate(nums): if val is not None and val > max_val: max_val, max_idx = val, idx ans.append((max_idx, max_val)) nums[max_idx] = None # 标记已选元素 # 按索引排序后提取值 return [val for idx, val in sorted(ans)] ``` --- #### 2. 堆（优先队列）优化法 **思路**：利用最大堆快速获取前 $k$ 个最大元素及其索引，再按索引排序恢复原始顺序。 - **时间复杂度**：$O(n \log n + k \log k)$，适合 $k$ 较大的情况。 - **空间复杂度**：$O(n)$。 ```python import heapq def maxSubsequence(nums, k): # 将元素和索引存入堆，按值降序排列 heap = [(-val, idx) for idx, val in enumerate(nums)] heapq.heapify(heap) # 取前k个元素（值最大的k个） selected = [] for _ in range(k): val, idx = heapq.heappop(heap) selected.append((idx, -val)) # 按索引排序后提取值 selected.sort() return [val for idx, val in selected] ``` --- ### 关键点对比 | 方法 | 适用场景 | 时间复杂度 | 空间复杂度 | |--------------|------------------|------------------|------------| | 选择排序法 | $k$ 较小 | $O(nk)$ | $O(1)$ | | 堆优化法 | $k$ 较大或通用 | $O(n \log n)$ | $O(n)$ | --- ### 典型用例 1. **输入**：$nums = [3,1,4,2], k = 2$ **输出**：$[3,4]$（子序列索引为0和2，和为7） 2. **输入**：$nums = [5,3,5,2], k = 2$ **输出**：$[5,5]$（索引0和2，和为10） ---