Lexicographically Minimum String After Removing Stars

Lexicographically Minimum String After Removing Stars - Problem

Hash Table String Stack Greedy Heap (Priority Queue) Medium

You're given a string s containing lowercase letters and asterisks (*). Your mission is to remove all asterisks by following a specific elimination rule that will give you the lexicographically smallest possible result.

The Elimination Rule: For each asterisk (*) you encounter:

Find the leftmost asterisk
Look to its left and find the smallest character (lexicographically)
Remove both the asterisk and that smallest character
If there are multiple smallest characters, you can remove any one of them

Goal: Return the lexicographically smallest string after removing all asterisks.

Example: In "abc*de*", the first * removes 'a' (smallest to its left), and the second * removes 'b', leaving "cde".

Input & Output

example_1.py — Basic Case

$ Input: s = "leet*cod*e"

› Output: "letcode"

💡 Note: First '*' removes smallest char to its left ('e' from 'leet'), leaving 'let*cod*e'. Second '*' removes 't', leaving 'lecod*e'. Last '*' removes 'c', giving final result 'letcode'.

example_2.py — Multiple Same Characters

$ Input: s = "erase*****"

› Output: ""

💡 Note: Each '*' removes one character: 'erase****' → 'rase***' → 'ase**' → 'se*' → 'e' → ''. All characters are eliminated.

example_3.py — No Stars

$ Input: s = "abc"

› Output: "abc"

💡 Note: No asterisks present, so the string remains unchanged.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of lowercase English letters and '*' characters
It is guaranteed that the string can be processed (no asterisk without preceding characters)

Visualization

Tap to expand

Understanding the Visualization

Add to Stack

Place each character on the stack as you encounter it

Track in Heap

Also add each character to a min-heap for quick smallest-element access

Process Asterisk

When you see *, remove the smallest character from heap and mark its stack position

Build Result

Collect all non-removed characters from the stack in their original order

Key Takeaway

🎯 Key Insight: The combination of stack (for order preservation) and min-heap (for efficient minimum finding) gives us the optimal balance between correctness and performance.

Asked in

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

The optimal approach uses a stack to track characters and a min-heap for efficient removal. As we traverse the string, regular characters go into both stack and heap. When we encounter an asterisk, we remove the smallest available character from the heap and mark its position as removed. Finally, we collect all non-removed characters from the stack to build our result. This achieves O(n log n) time complexity with single-pass processing.

Common Approaches

Approach	Time	Space	Notes
✓ Stack + Priority Queue (Optimal)	O(n log n)	O(n)	Use stack to track characters and min-heap to efficiently find smallest character
Brute Force (Repeated Linear Search)	O(n³)	O(n)	Find each asterisk, scan left for smallest character, remove both, repeat

Stack + Priority Queue (Optimal) — Algorithm Steps

Initialize a stack for characters and a min-heap for efficient smallest character lookup
Traverse the string character by character
For regular characters: push to stack and add to min-heap with its stack position
For asterisks: remove the smallest character from heap, mark it as removed in stack
Build the final result by collecting non-removed characters from the stack

Visualization

Tap to expand

Step-by-Step Walkthrough

Process characters

Add characters to stack and heap as we traverse

Handle asterisk

Remove smallest character from heap and mark as removed

Build result

Collect non-removed characters from stack

Code -

solution.c — C

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

typedef struct {
    char ch;
    int index;
} HeapItem;

typedef struct {
    HeapItem* items;
    int size;
    int capacity;
} MinHeap;

MinHeap* createHeap(int capacity) {
    MinHeap* heap = (MinHeap*)malloc(sizeof(MinHeap));
    heap->items = (HeapItem*)malloc(capacity * sizeof(HeapItem));
    heap->size = 0;
    heap->capacity = capacity;
    return heap;
}

void swap(HeapItem* a, HeapItem* b) {
    HeapItem temp = *a;
    *a = *b;
    *b = temp;
}

void heapifyUp(MinHeap* heap, int index) {
    int parent = (index - 1) / 2;
    if (index > 0 && (heap->items[index].ch < heap->items[parent].ch || 
                     (heap->items[index].ch == heap->items[parent].ch && 
                      heap->items[index].index < heap->items[parent].index))) {
        swap(&heap->items[index], &heap->items[parent]);
        heapifyUp(heap, parent);
    }
}

void heapifyDown(MinHeap* heap, int index) {
    int left = 2 * index + 1;
    int right = 2 * index + 2;
    int smallest = index;
    
    if (left < heap->size && (heap->items[left].ch < heap->items[smallest].ch || 
                             (heap->items[left].ch == heap->items[smallest].ch && 
                              heap->items[left].index < heap->items[smallest].index))) {
        smallest = left;
    }
    
    if (right < heap->size && (heap->items[right].ch < heap->items[smallest].ch || 
                              (heap->items[right].ch == heap->items[smallest].ch && 
                               heap->items[right].index < heap->items[smallest].index))) {
        smallest = right;
    }
    
    if (smallest != index) {
        swap(&heap->items[index], &heap->items[smallest]);
        heapifyDown(heap, smallest);
    }
}

void push(MinHeap* heap, char ch, int index) {
    heap->items[heap->size].ch = ch;
    heap->items[heap->size].index = index;
    heapifyUp(heap, heap->size);
    heap->size++;
}

HeapItem pop(MinHeap* heap) {
    HeapItem min = heap->items[0];
    heap->items[0] = heap->items[heap->size - 1];
    heap->size--;
    heapifyDown(heap, 0);
    return min;
}

char* removeStars(char* s) {
    int len = strlen(s);
    char* stack = (char*)malloc(len * sizeof(char));
    MinHeap* heap = createHeap(len);
    int* removed = (int*)calloc(len, sizeof(int));
    int stackSize = 0;
    
    for (int i = 0; i < len; i++) {
        if (s[i] == '*') {
            while (heap->size > 0 && removed[heap->items[0].index]) {
                pop(heap);
            }
            
            if (heap->size > 0) {
                HeapItem item = pop(heap);
                removed[item.index] = 1;
            }
        } else {
            stack[stackSize] = s[i];
            push(heap, s[i], stackSize);
            stackSize++;
        }
    }
    
    char* result = (char*)malloc((len + 1) * sizeof(char));
    int resultSize = 0;
    
    for (int i = 0; i < stackSize; i++) {
        if (!removed[i]) {
            result[resultSize++] = stack[i];
        }
    }
    
    result[resultSize] = '\0';
    
    free(stack);
    free(heap->items);
    free(heap);
    free(removed);
    
    return result;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Single pass O(n) with O(log n) heap operations for each character

⚡ Linearithmic

Space Complexity

O(n)

Stack and heap both store at most n characters

⚡ Linearithmic Space

78.5K Views

Medium-High Frequency

~18 min Avg. Time

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

Stack + Priority Queue (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler