Smallest Subsequence of Distinct Characters

Smallest Subsequence of Distinct Characters - Problem

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

A subsequence is a sequence that can be derived from another sequence by deleting some or no elements without changing the order of the remaining elements.

Example: For string "bcabc", we need to select one occurrence of each character ('a', 'b', 'c') such that the result is lexicographically smallest while maintaining the original order.

Input & Output

Example 1 — Basic Case

$ Input: s = "bcabc"

› Output: "abc"

💡 Note: We need each distinct character (a,b,c) exactly once. The lexicographically smallest subsequence maintaining original order is "abc"

Example 2 — All Different

$ Input: s = "ecbacba"

› Output: "eacb"

💡 Note: Distinct characters are {a,b,c,e}. The optimal subsequence is "eacb" - we can't improve it while maintaining order

Example 3 — Single Character

$ Input: s = "aaaa"

› Output: "a"

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

Constraints

1 ≤ s.length ≤ 1000
s consists of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 15 a Amazon 12 f Facebook 8

The key insight is using a monotonic stack to maintain lexicographically smallest order while ensuring all distinct characters are included exactly once. Best approach is the monotonic stack solution. Time: O(n), Space: O(k) where k is number of distinct characters.

Common Approaches

✓ Brute Force - Try All Subsequences

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

Generate every possible subsequence of the string, check if it contains all distinct characters exactly once, then return the lexicographically smallest valid subsequence.

Greedy - First Valid Characters

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

Sort the distinct characters and for each character in alphabetical order, pick its first occurrence that doesn't violate the constraint of including all remaining characters.

Monotonic Stack - Optimal Solution

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

Use a stack to maintain characters in increasing order. When encountering a smaller character, pop larger characters from stack only if they appear later in the string, ensuring we can still include all distinct characters.

Brute Force - Try All Subsequences — Algorithm Steps

Generate all 2^n possible subsequences
Filter subsequences that contain all distinct characters exactly once
Return the lexicographically smallest valid subsequence

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate All

Create every possible subsequence (2^n combinations)

Filter Valid

Keep only subsequences with all distinct chars once

Find Smallest

Return lexicographically smallest valid subsequence

Code -

solution.c — C

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

char* solution(char* s) {
    int n = strlen(s);
    bool distinctChars[256] = {false};
    int k = 0;
    
    // Count distinct characters
    for (int i = 0; i < n; i++) {
        if (!distinctChars[(unsigned char)s[i]]) {
            distinctChars[(unsigned char)s[i]] = true;
            k++;
        }
    }
    
    char* result = malloc((n + 1) * sizeof(char));
    strcpy(result, s);
    
    // Try all subsequences using bitmask
    for (int mask = 0; mask < (1 << n); mask++) {
        int bitCount = __builtin_popcount(mask);
        if (bitCount < k) continue;
        
        char subseq[n + 1];
        int idx = 0;
        
        for (int i = 0; i < n; i++) {
            if (mask & (1 << i)) {
                subseq[idx++] = s[i];
            }
        }
        subseq[idx] = '\0';
        
        // Check if contains all distinct chars
        bool subseqChars[256] = {false};
        int subseqDistinct = 0;
        
        for (int i = 0; i < idx; i++) {
            if (!subseqChars[(unsigned char)subseq[i]]) {
                subseqChars[(unsigned char)subseq[i]] = true;
                subseqDistinct++;
            }
        }
        
        if (subseqDistinct == k) {
            bool valid = true;
            for (int i = 0; i < 256; i++) {
                if (distinctChars[i] && !subseqChars[i]) {
                    valid = false;
                    break;
                }
            }
            
            if (valid && strcmp(subseq, result) < 0) {
                strcpy(result, subseq);
            }
        }
    }
    
    return result;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    char* result = solution(s);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Generate 2^n subsequences, each taking O(n) time to validate

✓ Linear Growth

Space Complexity

O(2^n)

Store all possible subsequences in memory

✓ Linear Space

23.4K Views

Medium Frequency

~25 min Avg. Time

892 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

Brute Force - Try All Subsequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler