Find Subsequence of Length K With the Largest Sum - Problem

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.

Input & Output

Example 1 — Basic Case

$ Input: nums = [2,1,3,1], k = 2

› Output: [2,3]

💡 Note: The subsequence has the largest sum among all subsequences of length 2. We select the largest values 3 and 2 while maintaining their original order.

Example 2 — All Positive Numbers

$ Input: nums = [-1,-2,3,4], k = 3

› Output: [-1,3,4]

💡 Note: The 3 largest values are 4, 3, and -1. In original order: [-1,3,4]. Sum = -1 + 3 + 4 = 6.

Example 3 — Single Element

$ Input: nums = [3,4,3,3], k = 2

› Output: [4,3]

💡 Note: We need any 2 elements with largest sum. The largest value 4 and any 3 will do. Taking indices [1,2] gives us [4,3].

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ k ≤ nums.length
-10⁵ ≤ nums[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to identify the k largest elements while preserving their relative order from the original array. The optimal Sort-First approach pairs each value with its index, sorts by value, selects the k largest, then restores original order. Time: O(n log n), Space: O(n).

Common Approaches

✓ Brute Force - Generate All Subsequences

⏱️ Time: O(2^n) Space: O(k)

This approach generates all possible combinations of k elements from the array, calculates the sum of each combination, and returns the one with the maximum sum while preserving order.

Min-Heap Approach

⏱️ Time: O(n log k) Space: O(k)

Maintain a min-heap of size k containing the k largest elements seen so far. For each element, if heap size is less than k, add the element. Otherwise, if current element is larger than heap's minimum, remove minimum and add current element.

Sort and Select Approach

⏱️ Time: O(n log n) Space: O(n)

Create pairs of (value, index), sort by value in descending order, take the k largest values, then sort their indices to maintain original order and extract the elements.

Brute Force - Generate All Subsequences — Algorithm Steps

Step 1: Generate all possible combinations of k indices from the array
Step 2: For each combination, calculate the sum of elements
Step 3: Track the combination with maximum sum and return those elements

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all possible combinations of k indices

Calculate

Sum elements for each combination

Select

Choose combination with maximum sum

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    int value;
    int index;
} Element;

int compare(const void* a, const void* b) {
    Element* ea = (Element*)a;
    Element* eb = (Element*)b;
    if (ea->value != eb->value) {
        return eb->value - ea->value; // descending by value
    }
    return ea->index - eb->index; // ascending by index for stability
}

int compareIndex(const void* a, const void* b) {
    Element* ea = (Element*)a;
    Element* eb = (Element*)b;
    return ea->index - eb->index;
}

int main() {
    char line[10000];
    if (!fgets(line, sizeof(line), stdin)) return 1;
    
    int nums[1000];
    int n = 0;
    
    // Parse array format [2,1,3,1]
    char* ptr = line;
    while (*ptr && *ptr != '[') ptr++;
    if (*ptr) ptr++; // skip '['
    
    while (*ptr && *ptr != ']') {
        if (*ptr == ',' || *ptr == ' ' || *ptr == '\t') {
            ptr++;
            continue;
        }
        
        if (*ptr == '-' || (*ptr >= '0' && *ptr <= '9')) {
            int num = 0;
            int negative = 0;
            if (*ptr == '-') {
                negative = 1;
                ptr++;
            }
            while (*ptr >= '0' && *ptr <= '9') {
                num = num * 10 + (*ptr - '0');
                ptr++;
            }
            if (negative) num = -num;
            nums[n++] = num;
        } else {
            ptr++;
        }
    }
    
    int k;
    scanf("%d", &k);
    
    // Create array of elements with their indices
    Element* elements = (Element*)malloc(n * sizeof(Element));
    for (int i = 0; i < n; i++) {
        elements[i].value = nums[i];
        elements[i].index = i;
    }
    
    // Sort by value (descending) to get k largest
    qsort(elements, n, sizeof(Element), compare);
    
    // Take first k elements and sort by original index to preserve order
    qsort(elements, k, sizeof(Element), compareIndex);
    
    // Output the subsequence
    printf("[");
    for (int i = 0; i < k; i++) {
        printf("%d", elements[i].value);
        if (i < k - 1) printf(",");
    }
    printf("]\n");
    
    free(elements);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

We generate all possible combinations which is exponential in nature

⚡ Linearithmic

Space Complexity

O(k)

Only need space to store the result subsequence of length k

⚡ Linearithmic Space

23.5K Views

Medium Frequency

~15 min Avg. Time

850 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Find Subsequence of Length K With the Largest Sum - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force - Generate All Subsequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler