Using a Robot to Print the Lexicographically Smallest String

Using a Robot to Print the Lexicographically Smallest String - Problem

You are given a string s and a robot that currently holds an empty string t. Apply one of the following operations until s and t are both empty:

Remove the first character of string s and give it to the robot. The robot will append this character to the string t.
Remove the last character of string t and give it to the robot. The robot will write this character on paper.

Return the lexicographically smallest string that can be written on paper.

Input & Output

Example 1 — Basic Case

$ Input: s = "zab"

› Output: "abz"

💡 Note: Move z to stack, move a to stack, pop a (smaller than remaining min 'b'), move b to stack, pop b, pop z. Result: a + b + z = "abz"

Example 2 — Already Sorted

$ Input: s = "bac"

› Output: "abc"

💡 Note: Move b to stack, move a to stack, pop a (≤ remaining min 'a'), move c to stack, pop c (≤ remaining min 'c'), pop b. Result: a + b + c = "abc"

Example 3 — Reverse Order

$ Input: s = "cba"

› Output: "abc"

💡 Note: Move c to stack, move b to stack, pop b (≤ remaining min 'a'), move a to stack, pop a (≤ remaining min 'a'), pop c. Result: b + a + c = "bac" is wrong. Actually: we get a + b + c = "abc" by optimal popping strategy

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 8

The key insight is to use a stack with lookahead - we can delay popping characters from the stack if better (smaller) characters are coming later. The greedy approach with suffix array preprocessing gives us O(n) time complexity by making optimal decisions about when to output characters. Time: O(n), Space: O(n)

Common Approaches

✓ Brute Force - Try All Sequences

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

At each step, we can either move a character from s to t or from t to result. Try both options recursively and keep track of the lexicographically smallest result found.

Greedy with Stack and Suffix Array

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

Pre-compute the smallest character remaining in each suffix. Use a stack to temporarily store characters from s, and greedily pop from the stack when the top character is smaller than or equal to the minimum character remaining.

Brute Force - Try All Sequences — Algorithm Steps

Try moving character from s to t
Try moving character from t to result
Recursively explore all possibilities
Return the lexicographically smallest result

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

s='zab', t='', result=''

Branch 1

Move 'z' from s to t

Branch 2

Continue exploring all paths recursively

Code -

solution.c — C

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

char* backtrack(const char* s, int sIdx, const char* t, int tLen, const char* result, int resLen, int sLen) {
    if (sIdx == sLen && tLen == 0) {
        char* final = (char*)malloc((resLen + 1) * sizeof(char));
        if (resLen > 0) {
            memcpy(final, result, resLen);
        }
        final[resLen] = '\0';
        return final;
    }
    
    char* best = NULL;
    
    // Option 1: Move from s to t
    if (sIdx < sLen) {
        // Create new t with the additional character
        char* newT = (char*)malloc((tLen + 2) * sizeof(char));
        if (tLen > 0) {
            memcpy(newT, t, tLen);
        }
        newT[tLen] = s[sIdx];
        newT[tLen + 1] = '\0';
        
        char* newResult = backtrack(s, sIdx + 1, newT, tLen + 1, result, resLen, sLen);
        free(newT);
        
        if (newResult != NULL) {
            if (best == NULL || strcmp(newResult, best) < 0) {
                if (best != NULL) {
                    free(best);
                }
                best = newResult;
            } else {
                free(newResult);
            }
        }
    }
    
    // Option 2: Move from t to result
    if (tLen > 0) {
        char ch = t[tLen - 1];
        
        // Create new result with the additional character
        char* newResult = (char*)malloc((resLen + 2) * sizeof(char));
        if (resLen > 0) {
            memcpy(newResult, result, resLen);
        }
        newResult[resLen] = ch;
        newResult[resLen + 1] = '\0';
        
        // Create new t without the last character
        char* newT = (char*)malloc((tLen) * sizeof(char));
        if (tLen > 1) {
            memcpy(newT, t, tLen - 1);
        }
        newT[tLen - 1] = '\0';
        
        char* recursiveResult = backtrack(s, sIdx, newT, tLen - 1, newResult, resLen + 1, sLen);
        free(newT);
        free(newResult);
        
        if (recursiveResult != NULL) {
            if (best == NULL || strcmp(recursiveResult, best) < 0) {
                if (best != NULL) {
                    free(best);
                }
                best = recursiveResult;
            } else {
                free(recursiveResult);
            }
        }
    }
    
    return best;
}

char* solution(char* s) {
    int sLen = strlen(s);
    char* emptyT = (char*)malloc(1 * sizeof(char));
    emptyT[0] = '\0';
    char* emptyResult = (char*)malloc(1 * sizeof(char));
    emptyResult[0] = '\0';
    
    char* answer = backtrack(s, 0, emptyT, 0, emptyResult, 0, sLen);
    
    free(emptyT);
    free(emptyResult);
    return answer;
}

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ⁿ)

At each step we have 2 choices, leading to exponential possibilities

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth and string storage

⚡ Linearithmic 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 Sequences — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler