Using a Robot to Print the Lexicographically Smallest String

Using a Robot to Print the Lexicographically Smallest String - Problem

You control a robot that helps you create the lexicographically smallest possible string from a given input string s. The robot has an internal stack t (initially empty) and can perform exactly two operations:

Push Operation: Take the first character from string s and push it onto stack t
Pop Operation: Pop the top character from stack t and write it to the result paper

Your goal is to determine the optimal sequence of operations to produce the lexicographically smallest string possible. You must continue until both s and t are completely empty.

Example: Given s = "bdda", you could push 'b' to stack, then 'd', then pop 'd' (write 'd'), pop 'b' (write 'b'), push 'd', push 'a', pop 'a' (write 'a'), pop 'd' (write 'd') to get "dbad". But there's a better sequence that gives "addb"!

Input & Output

example_1.py — Basic Case

$ Input: s = "bdda"

› Output: "addb"

💡 Note: Optimal sequence: push 'b', push 'd', push 'd', push 'a', pop 'a' (write), pop 'd' (write), pop 'd' (write), pop 'b' (write) → "addb"

example_2.py — Already Sorted

$ Input: s = "abc"

› Output: "abc"

💡 Note: Since the string is already in lexicographical order, we can simply push each character and immediately pop it: push 'a', pop 'a', push 'b', pop 'b', push 'c', pop 'c' → "abc"

example_3.py — Single Character

$ Input: s = "x"

› Output: "x"

💡 Note: With only one character, we must push it onto the stack and then pop it to complete the process → "x"

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters only
Both s and t must be empty at the end

Visualization

Tap to expand

Understanding the Visualization

Initialize

Create suffix frequency map and empty stack

Process Characters

For each input character, make optimal push/pop decisions

Greedy Choice

Pop larger characters from stack only if they appear later

Complete

Pop remaining stack characters to finish the result

Key Takeaway

🎯 Key Insight: The optimal solution combines greedy decision-making with lookahead information (suffix frequencies) to ensure we always place the smallest possible character next in our result.

Asked in

G Google 25 a Amazon 18 f Meta 12 ⊞ Microsoft 8

The optimal solution uses a greedy approach with suffix frequency tracking. Build a frequency map of remaining characters, then use a stack to temporarily hold characters. The key insight is to pop from the stack when the stack top is larger than the current character AND the stack top appears later in the string. This ensures we always place smaller characters first while maintaining the constraint that we can only access characters through the stack or input sequence.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Possible Sequences)	O(2^n)	O(n)	Generate all possible sequences of operations and find the lexicographically smallest result
Greedy with Suffix Frequency (Optimal)	O(n)	O(n)	Use greedy strategy with suffix frequency map to make optimal decisions in one pass

Brute Force (Try All Possible Sequences) — Algorithm Steps

Start with empty stack t and full string s
At each step, try all valid operations (push from s or pop from t)
Use recursion/backtracking to explore all possible sequences
Keep track of the lexicographically smallest result found
Return the best result after exploring all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with string s and empty stack t

Branch on Operations

At each step, try both push and pop operations if valid

Explore All Paths

Continue recursively until both s and t are empty

Compare Results

Keep track of lexicographically smallest result found

Code -

solution.c — C

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

#define MAX_LEN 1000

char* backtrack(char* s, int sIdx, char* stack, int stackTop, char* result, int resultLen) {
    int sLen = strlen(s);
    
    // Base case: both s and stack are empty
    if (sIdx == sLen && stackTop == -1) {
        char* final = malloc((resultLen + 1) * sizeof(char));
        strcpy(final, result);
        return final;
    }
    
    char* best = NULL;
    
    // Try popping from stack if possible
    if (stackTop >= 0) {
        char popped = stack[stackTop];
        result[resultLen] = popped;
        result[resultLen + 1] = '\0';
        
        char* candidate = backtrack(s, sIdx, stack, stackTop - 1, result, resultLen + 1);
        result[resultLen] = '\0'; // backtrack
        
        if (candidate && (!best || strcmp(candidate, best) < 0)) {
            if (best) free(best);
            best = candidate;
        } else if (candidate) {
            free(candidate);
        }
    }
    
    // Try pushing from s if possible
    if (sIdx < sLen) {
        stack[stackTop + 1] = s[sIdx];
        char* candidate = backtrack(s, sIdx + 1, stack, stackTop + 1, result, resultLen);
        
        if (candidate && (!best || strcmp(candidate, best) < 0)) {
            if (best) free(best);
            best = candidate;
        } else if (candidate) {
            free(candidate);
        }
    }
    
    return best;
}

char* robotWithString(char* s) {
    char stack[MAX_LEN];
    char result[MAX_LEN];
    result[0] = '\0';
    return backtrack(s, 0, stack, -1, result, 0);
}

int main() {
    char s[MAX_LEN];
    scanf("%s", s);
    char* result = robotWithString(s);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

At each step we have up to 2 choices, leading to exponential branching

⚠ Quadratic Growth

Space Complexity

O(n)

Recursion depth and stack storage

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~25 min Avg. Time

847 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 Possible Sequences) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler