Welcome to Subscribe On Youtube

2099. Find Subsequence of Length K With the Largest Sum

Description

You are given an integer array nums and an integer k. You want to find a subsequence of nums of length k that has the largest sum.

Return any such subsequence as an integer array of length k.

A subsequence is an array that can be derived from another array by deleting some or no elements without changing the order of the remaining elements.

 

Example 1:

Input: nums = [2,1,3,3], k = 2
Output: [3,3]
Explanation:
The subsequence has the largest sum of 3 + 3 = 6.

Example 2:

Input: nums = [-1,-2,3,4], k = 3
Output: [-1,3,4]
Explanation: 
The subsequence has the largest sum of -1 + 3 + 4 = 6.

Example 3:

Input: nums = [3,4,3,3], k = 2
Output: [3,4]
Explanation:
The subsequence has the largest sum of 3 + 4 = 7. 
Another possible subsequence is [4, 3].

 

Constraints:

  • 1 <= nums.length <= 1000
  • -105 <= nums[i] <= 105
  • 1 <= k <= nums.length

Solutions

  • class Solution {
        public int[] maxSubsequence(int[] nums, int k) {
            int[] ans = new int[k];
            List<Integer> idx = new ArrayList<>();
            int n = nums.length;
            for (int i = 0; i < n; ++i) {
                idx.add(i);
            }
            idx.sort(Comparator.comparingInt(i -> - nums[i]));
            int[] t = new int[k];
            for (int i = 0; i < k; ++i) {
                t[i] = idx.get(i);
            }
            Arrays.sort(t);
            for (int i = 0; i < k; ++i) {
                ans[i] = nums[t[i]];
            }
            return ans;
        }
    }
    
  • class Solution {
    public:
        vector<int> maxSubsequence(vector<int>& nums, int k) {
            int n = nums.size();
            vector<pair<int, int>> vals;
            for (int i = 0; i < n; ++i) vals.push_back({i, nums[i]});
            sort(vals.begin(), vals.end(), [&](auto x1, auto x2) {
                return x1.second > x2.second;
            });
            sort(vals.begin(), vals.begin() + k);
            vector<int> ans;
            for (int i = 0; i < k; ++i) ans.push_back(vals[i].second);
            return ans;
        }
    };
    
  • class Solution:
        def maxSubsequence(self, nums: List[int], k: int) -> List[int]:
            idx = list(range(len(nums)))
            idx.sort(key=lambda i: nums[i])
            return [nums[i] for i in sorted(idx[-k:])]
    
    
  • func maxSubsequence(nums []int, k int) []int {
    	idx := make([]int, len(nums))
    	for i := range idx {
    		idx[i] = i
    	}
    	sort.Slice(idx, func(i, j int) bool { return nums[idx[i]] > nums[idx[j]] })
    	sort.Ints(idx[:k])
    	ans := make([]int, k)
    	for i, j := range idx[:k] {
    		ans[i] = nums[j]
    	}
    	return ans
    }
    
  • function maxSubsequence(nums: number[], k: number): number[] {
        const n = nums.length;
        const idx: number[] = Array.from({ length: n }, (_, i) => i);
        idx.sort((i, j) => nums[i] - nums[j]);
        return idx
            .slice(n - k)
            .sort((i, j) => i - j)
            .map(i => nums[i]);
    }
    
    

All Problems

All Solutions