Smallest K-Length Subsequence With Occurrences of a Letter

Smallest K-Length Subsequence With Occurrences of a Letter - Problem

Given a string s, you need to construct the lexicographically smallest subsequence that meets specific constraints. This is like finding the "best" characters from the string while maintaining their original order!

Your task: Extract exactly k characters from string s to form a subsequence that:

Has length exactly k
Contains the specified letter at least repetition times
Is the lexicographically smallest among all valid subsequences

Remember: A subsequence maintains the relative order of characters from the original string, but you can skip any characters you don't need.

Example: From "leetcode", if you need 4 characters with 'e' appearing at least 2 times, the answer would be "ecde" (not "eete" because 'c' < 't' lexicographically).

Input & Output

example_1.py — Basic case

$ Input: s = "leet", k = 3, letter = "e", repetition = 1

› Output: "eet"

💡 Note: We need 3 characters with at least 1 'e'. The subsequences could be "lee", "let", "eet", "elt", "elt". Among these, "eet" is lexicographically smallest.

example_2.py — Multiple constraints

$ Input: s = "leetcode", k = 4, letter = "e", repetition = 2

› Output: "ecde"

💡 Note: We need 4 characters with at least 2 'e's. We start building "ee" but when we see 'c', we can optimize to "ec" then add 'd' and another 'e' to get "ecde" which is optimal.

example_3.py — Edge case with high repetition

$ Input: s = "aaabbbccceeee", k = 6, letter = "e", repetition = 4

› Output: "abceee"

💡 Note: We need exactly 6 characters with at least 4 'e's. Since we must have 4 'e's, we can only choose 2 other characters. The smallest available are 'a', 'b', and 'c', so we pick 'a' and 'b' giving us "abceee".

Visualization

Tap to expand

Understanding the Visualization

Count Resources

First count how many VIP players are available in total

Greedy Selection

For each candidate, decide if they improve your current team

Smart Replacement

If a better candidate arrives, remove weaker ones from the end - but ensure VIP quota is still achievable

Constraint Checking

Always verify you can meet both team size and VIP requirements with remaining candidates

Final Team

Your stack contains the optimal team meeting all constraints

Key Takeaway

🎯 Key Insight: The monotonic stack approach ensures we always make locally optimal decisions (keeping smaller characters) while maintaining global constraints (required letter count). This greedy strategy works because we can always verify if future requirements can still be met.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string, each character pushed and popped at most once

✓ Linear Growth

Space Complexity

O(k)

Stack stores at most k characters for the result subsequence

✓ Linear Space

Constraints

1 ≤ s.length ≤ 5 × 10⁴
1 ≤ k ≤ s.length
s consists of lowercase English letters
letter is a lowercase English letter
1 ≤ repetition ≤ k
The letter appears in s at least repetition times

Asked in

G Google 42 a Amazon 35 f Meta 28 ⊞ Microsoft 22 Apple 18

The optimal solution uses a monotonic stack approach to build the lexicographically smallest subsequence. Key insights: (1) Use a greedy strategy to remove larger characters when smaller ones arrive, (2) Always ensure the required letter count can still be satisfied with remaining characters, (3) Process characters in a single pass with O(n) time complexity. The stack maintains the result while ensuring both length and letter constraints are met.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Generate All Subsequences)	O(2^n * k)	O(2^n * k)	Generate all possible subsequences of length k and find the lexicographically smallest valid one
Monotonic Stack (Optimal)	O(n)	O(k)	Use a stack to build the result greedily while ensuring letter requirements are met

Brute Force (Generate All Subsequences) — Algorithm Steps

Generate all possible subsequences of length k using backtracking
For each subsequence, count occurrences of the required letter
Keep only subsequences that meet the letter requirement
Return the lexicographically smallest valid subsequence

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with empty subsequence

Begin at index 0 with empty result

For each character, make two choices

Include it or skip it in our subsequence

Check constraints at length k

Verify letter count and lexicographical order

Backtrack and try next possibility

Explore all 2^n possible combinations

Code -

solution.c — C

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

char best_result[1001];
int found_result = 0;

void backtrack(char* s, int idx, char* current, int current_len, 
              int letter_count, int k, char letter, int repetition, int s_len) {
    if (current_len == k) {
        if (letter_count >= repetition && (!found_result || strcmp(current, best_result) < 0)) {
            strcpy(best_result, current);
            found_result = 1;
        }
        return;
    }
    
    if (idx >= s_len || current_len + (s_len - idx) < k) return;
    
    // Include current character
    current[current_len] = s[idx];
    current[current_len + 1] = '\0';
    int new_count = letter_count + (s[idx] == letter ? 1 : 0);
    backtrack(s, idx + 1, current, current_len + 1, new_count, k, letter, repetition, s_len);
    
    // Skip current character
    current[current_len] = '\0';
    backtrack(s, idx + 1, current, current_len, letter_count, k, letter, repetition, s_len);
}

int main() {
    char input[1001];
    fgets(input, sizeof(input), stdin);
    
    char s[1001], letter_str[10];
    int k, repetition;
    sscanf(input, "\"%[^\"]\",%%d,\"%c\",%%d", s, &k, &letter_str[0], &repetition);
    
    char current[1001] = "";
    found_result = 0;
    backtrack(s, 0, current, 0, 0, k, letter_str[0], repetition, strlen(s));
    
    printf("%s\n", best_result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n * k)

We generate 2^n possible subsequences, and for each we spend O(k) time to validate and compare

⚠ Quadratic Growth

Space Complexity

O(2^n * k)

In worst case, we might store all possible subsequences of length k

⚠ Quadratic Space

Constraints

1 ≤ s.length ≤ 5 × 10⁴
1 ≤ k ≤ s.length
s consists of lowercase English letters
letter is a lowercase English letter
1 ≤ repetition ≤ k
The letter appears in s at least repetition times

23.3K Views

Medium-High Frequency

~25 min Avg. Time

987 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Generate All Subsequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler