Smallest Subsequence of Distinct Characters

Smallest Subsequence of Distinct Characters - Problem

Imagine you have a string of characters and you need to pick the lexicographically smallest subsequence that contains every distinct character exactly once. This is like creating the most optimal representative sample from your string!

Given a string s, your task is to return the lexicographically smallest subsequence of s that contains all the distinct characters of s exactly once.

What makes this challenging?

You must maintain the relative order of characters from the original string (subsequence property)
You want the lexicographically smallest result possible
Each distinct character must appear exactly once

Example: For string "cbacdcbc", the answer is "acdb" because it's the smallest possible subsequence containing all distinct characters {a, b, c, d} exactly once.

Input & Output

example_1.py — Basic Case

$ Input: s = "bcabc"

› Output: "abc"

💡 Note: The distinct characters are 'a', 'b', and 'c'. The lexicographically smallest subsequence containing all of them exactly once is "abc".

example_2.py — Complex Case

$ Input: s = "cbacdcbc"

› Output: "acdb"

💡 Note: The distinct characters are 'a', 'b', 'c', and 'd'. We need to find the lexicographically smallest subsequence. Starting with 'a', then 'c' (since we need it), then 'd', then 'b' gives us "acdb".

example_3.py — Single Character

$ Input: s = "aaa"

› Output: "a"

💡 Note: Only one distinct character 'a', so the result is "a".

Constraints

1 ≤ s.length ≤ 10⁴
s consists of lowercase English letters
Important: The result must be a subsequence (maintain relative order) and contain each distinct character exactly once

Visualization

Tap to expand

Understanding the Visualization

Count Resources

Count how many times each character appears - this tells us if we can afford to skip a character now

Greedy Selection

For each character, decide whether to include it now or wait for a better position

Smart Backtracking

If we find a better character, remove recent worse choices (but only if they can be added back later)

Optimal Result

The stack contains our optimal selection maintaining both lexicographic order and the subsequence property

Key Takeaway

🎯 Key Insight: The monotonic stack allows us to make locally optimal decisions while maintaining the ability to backtrack when we discover globally better choices, as long as we haven't exhausted our future opportunities for the characters we remove.

Asked in

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

The optimal solution uses a monotonic stack with character frequency tracking. Key insight: we can remove characters from our result if we find a lexicographically smaller character, as long as the removed character appears again later. This achieves O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Monotonic Stack (Optimal)	O(n)	O(1)	Use a stack with character frequency tracking to build the optimal subsequence in one pass
Brute Force (Generate All Subsequences)	O(2^n × n)	O(2^n × n)	Generate all possible subsequences and find the lexicographically smallest valid one

Monotonic Stack (Optimal) — Algorithm Steps

Count the frequency of each character in the string
Iterate through the string, maintaining a stack and a 'used' set
For each character, decrease its remaining count
If character is already used, skip it
While stack top is greater than current character AND stack top appears later, pop it
Add current character to stack and mark as used
Return the stack contents as the result

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Characters

Count frequency of each character for future reference

Process Each Character

Decrease count and check if already used

Maintain Stack Order

Remove larger characters that will appear again

Add Character

Push current character and mark as used

Code -

solution.c — C

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

char* smallestSubsequence(char* s) {
    int len = strlen(s);
    int count[26] = {0};
    
    // Count frequency of each character
    for (int i = 0; i < len; i++) {
        count[s[i] - 'a']++;
    }
    
    char* stack = (char*)malloc((len + 1) * sizeof(char));
    int stackTop = -1;
    int used[26] = {0};
    
    for (int i = 0; i < len; i++) {
        char c = s[i];
        
        // Decrease the count as we process this character
        count[c - 'a']--;
        
        // Skip if already used
        if (used[c - 'a']) {
            continue;
        }
        
        // Remove characters that are lexicographically larger than current
        // and will appear again later
        while (stackTop >= 0 && stack[stackTop] > c && count[stack[stackTop] - 'a'] > 0) {
            char removed = stack[stackTop];
            stackTop--;
            used[removed - 'a'] = 0;
        }
        
        // Add current character
        stack[++stackTop] = c;
        used[c - 'a'] = 1;
    }
    
    stack[stackTop + 1] = '\0';
    return stack;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    
    // Remove quotes and newline
    char* start = s;
    if (*start == '"') start++;
    int len = strlen(start);
    if (len > 0 && (start[len-1] == '"' || start[len-1] == '\n')) {
        start[len-1] = '\0';
        len--;
    }
    if (len > 0 && start[len-1] == '"') {
        start[len-1] = '\0';
    }
    
    char* result = smallestSubsequence(start);
    printf("\"%s\"\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

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

✓ Linear Growth

Space Complexity

O(1)

Only uses fixed-size arrays for 26 lowercase letters (or 256 for all ASCII)

✓ Linear Space

52.0K Views

High Frequency

~18 min Avg. Time

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

Monotonic Stack (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler