Find the Most Competitive Subsequence

Find the Most Competitive Subsequence - Problem

Given an integer array nums and a positive integer k, you need to find the most competitive subsequence of nums with exactly k elements.

A subsequence is formed by removing some (possibly zero) elements from the original array while maintaining the relative order of remaining elements. Think of it as selecting elements from left to right without changing their positions.

What makes one subsequence "more competitive" than another? Simple - it's lexicographically smaller! When comparing two subsequences of the same length, the one that has a smaller number at the first differing position wins.

Example: [1,3,4] beats [1,3,5] because at the third position, 4 < 5.

Your goal is to find the subsequence that would come first if all possible subsequences of size k were sorted in ascending order.

Input & Output

example_1.py — Basic Case

$ Input: nums = [3,5,2,6], k = 2

› Output: [2,6]

💡 Note: Among all possible subsequences of size 2: [3,5], [3,2], [3,6], [5,2], [5,6], [2,6]. The subsequence [2,6] is the most competitive because it starts with 2, which is the smallest possible first element.

example_2.py — Longer Subsequence

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

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

💡 Note: We need to select 4 elements. Starting with 2 (smallest possible), then 3, then another 3, and finally 4. This gives us the lexicographically smallest subsequence of length 4.

example_3.py — Edge Case

$ Input: nums = [71,18,52,29,55,73,24,42,66,8,80,2], k = 3

› Output: [18,24,2]

💡 Note: Even though 8 and 2 are the two smallest numbers, we can't use both while maintaining order. The optimal solution is [18,24,2] which is lexicographically smallest among all valid subsequences.

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Scan Players Left to Right

Go through each player in formation order

Smart Elimination

Remove weaker players from roster when stronger ones appear, if we can still complete the team

Build Optimal Team

Maintain the strongest possible team at each step

Key Takeaway

🎯 Key Insight: Use monotonic stack to greedily build the lexicographically smallest subsequence by removing larger elements when smaller ones appear, ensuring we can still complete a valid subsequence.

Asked in

G Google 45 a Amazon 38 f Meta 25 ⊞ Microsoft 18

The optimal solution uses a monotonic stack approach with O(n) time complexity. We iterate through the array and maintain a stack where we greedily remove larger elements when we encounter smaller ones, but only if we can still form a valid subsequence of size k. This greedy strategy ensures we get the lexicographically smallest (most competitive) subsequence.

Common Approaches

Approach	Time	Space	Notes
✓ Monotonic Stack (Optimal)	O(n)	O(k)	Use a monotonic stack to greedily build the most competitive subsequence
Brute Force (Generate All Subsequences)	O(C(n,k) * k)	O(k)	Generate all possible subsequences of size k and find the lexicographically smallest one

Monotonic Stack (Optimal) — Algorithm Steps

Initialize an empty stack to store our result
For each number in the array, while the stack is not empty and the top element is greater than current number and we can still form a valid subsequence, pop from stack
Add current number to stack if stack size is less than k
Return the stack as our most competitive subsequence

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Each Element

Go through array elements one by one

Pop Larger Elements

Remove larger elements from stack when beneficial

Add Current Element

Add current element if space available

Code -

solution.c — C

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

int* mostCompetitive(int* nums, int numsSize, int k, int* returnSize) {
    int* stack = (int*)malloc(k * sizeof(int));
    int stackSize = 0;
    
    for (int i = 0; i < numsSize; i++) {
        while (stackSize > 0 && 
               stack[stackSize - 1] > nums[i] && 
               stackSize - 1 + numsSize - i >= k) {
            stackSize--;
        }
        
        if (stackSize < k) {
            stack[stackSize++] = nums[i];
        }
    }
    
    *returnSize = k;
    return stack;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is pushed and popped at most once from the stack

✓ Linear Growth

Space Complexity

O(k)

Stack space to store at most k elements

✓ Linear Space

42.3K Views

Medium-High Frequency

~18 min Avg. Time

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