Find Subsequence of Length K With the Largest Sum

Find Subsequence of Length K With the Largest Sum - Problem

You are given an integer array nums and an integer k. Your goal is to find a subsequence of exactly k elements from the array that has the largest possible sum.

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

What is a subsequence? A subsequence is derived from the original array by deleting some or no elements without changing the order of the remaining elements. For example, from [3, 6, 2, 7], valid subsequences include [3, 6, 7] and [6, 2].

Key constraint: You must maintain the original order of elements from the input array in your result.

Input & Output

example_1.py — Basic Case

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

› Output: [3,3]

💡 Note: The subsequence has the largest sum of 3 + 3 = 6. We select the two 3's while maintaining their original order (indices 2 and 3).

example_2.py — Mixed Values

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

› Output: [-1,3,4]

💡 Note: The subsequence has sum (-1) + 3 + 4 = 6. We skip -2 (the smallest) and take the 3 largest values while maintaining order.

example_3.py — All Elements

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

› Output: [3,4,3,3]

💡 Note: When k equals the array length, we must take all elements. The sum is 3 + 4 + 3 + 3 = 13.

Constraints

1 ≤ nums.length ≤ 1000
1 ≤ k ≤ nums.length
-10⁵ ≤ nums[i] ≤ 10⁵
The answer is guaranteed to be unique

Visualization

Tap to expand

Understanding the Visualization

Scout Each Player

Examine each player's skill level as you move down the lineup

Maintain Top K

Keep track of the k best players seen so far, replacing weaker ones

Preserve Formation

Selected players maintain their original lineup positions

Final Team

Output the selected players in their formation order

Key Takeaway

🎯 Key Insight: Use a min-heap to efficiently track the k strongest players, then arrange them in formation order. This strategy balances selection efficiency with formation constraints!

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28 Apple 22

The optimal solution uses a min-heap (priority queue) to efficiently maintain the k largest elements while preserving their original indices. This achieves O(n log k) time complexity and O(k) space complexity, making it both time and space efficient compared to sorting the entire array.

Common Approaches

Approach	Time	Space	Notes
✓ Priority Queue (Optimal)	O(n log k)	O(k)	Use a min-heap to efficiently track k largest elements with their indices
Two-Pass with Index Tracking	O(n log n)	O(n)	Find k largest elements with their indices, then reconstruct in original order
Brute Force (Generate All Subsequences)	O(C(n,k) * k)	O(k)	Generate all possible subsequences of length k and find the one with maximum sum

Priority Queue (Optimal) — Algorithm Steps

Iterate through the array once
For each element, add (value, index) to min-heap
If heap size exceeds k, remove the smallest element
After processing all elements, extract elements from heap
Sort extracted elements by their original indices
Return values in original order

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Heap

Start with empty min-heap of capacity k

Process Elements

Add each element to heap, maintaining size ≤ k

Maintain K Largest

When heap exceeds k, remove smallest element

Extract & Sort

Sort final k elements by original indices

Code -

solution.c — C

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

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

typedef struct {
    Item* items;
    int size;
    int capacity;
} MinHeap;

MinHeap* createHeap(int capacity) {
    MinHeap* heap = (MinHeap*)malloc(sizeof(MinHeap));
    heap->items = (Item*)malloc(capacity * sizeof(Item));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void heapifyUp(MinHeap* heap, int index) {
    while (index > 0) {
        int parent = (index - 1) / 2;
        if (heap->items[parent].value <= heap->items[index].value) break;
        
        Item temp = heap->items[parent];
        heap->items[parent] = heap->items[index];
        heap->items[index] = temp;
        
        index = parent;
    }
}

void heapifyDown(MinHeap* heap, int index) {
    while (1) {
        int minIndex = index;
        int leftChild = 2 * index + 1;
        int rightChild = 2 * index + 2;
        
        if (leftChild < heap->size && heap->items[leftChild].value < heap->items[minIndex].value) {
            minIndex = leftChild;
        }
        if (rightChild < heap->size && heap->items[rightChild].value < heap->items[minIndex].value) {
            minIndex = rightChild;
        }
        
        if (minIndex == index) break;
        
        Item temp = heap->items[index];
        heap->items[index] = heap->items[minIndex];
        heap->items[minIndex] = temp;
        
        index = minIndex;
    }
}

void heapPush(MinHeap* heap, Item item) {
    heap->items[heap->size] = item;
    heapifyUp(heap, heap->size);
    heap->size++;
}

Item heapPop(MinHeap* heap) {
    Item result = heap->items[0];
    heap->items[0] = heap->items[heap->size - 1];
    heap->size--;
    heapifyDown(heap, 0);
    return result;
}

int compareByIndex(const void* a, const void* b) {
    Item* ia = (Item*)a;
    Item* ib = (Item*)b;
    return ia->index - ib->index;
}

int* largestSumSubsequence(int* nums, int numsSize, int k, int* returnSize) {
    MinHeap* heap = createHeap(k + 1);
    
    for (int i = 0; i < numsSize; i++) {
        Item item = {nums[i], i};
        heapPush(heap, item);
        
        if (heap->size > k) {
            heapPop(heap);
        }
    }
    
    // Sort by original indices
    qsort(heap->items, heap->size, sizeof(Item), compareByIndex);
    
    // Extract values
    int* result = (int*)malloc(k * sizeof(int));
    for (int i = 0; i < heap->size; i++) {
        result[i] = heap->items[i].value;
    }
    
    *returnSize = heap->size;
    free(heap->items);
    free(heap);
    return result;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log k)

Each of n elements may trigger heap operations costing O(log k), plus O(k log k) for final sorting

⚡ Linearithmic

Space Complexity

O(k)

Heap stores at most k elements with their indices

✓ Linear Space

42.3K Views

Medium-High Frequency

~15 min Avg. Time

1.8K 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Priority Queue (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler