Remove Invalid Parentheses

Remove Invalid Parentheses - Problem

Given a string s that contains parentheses and letters, remove the minimum number of invalid parentheses to make the input string valid.

Return a list of unique strings that are valid with the minimum number of removals. You may return the answer in any order.

A valid string has properly matched parentheses where:

Every opening parenthesis ( has a corresponding closing parenthesis )
The closing parentheses appear after their corresponding opening parentheses

Input & Output

Example 1 — Extra Closing Parenthesis

$ Input: s = "()())"

› Output: ["()()", "(())"]

💡 Note: Remove one ')' to get valid strings. Two possibilities: remove the 4th character to get "()()" or remove the 5th character to get "(())"

Example 2 — Multiple Invalid Parentheses

$ Input: s = "((("

› Output: [""]

💡 Note: All three opening parentheses are invalid since there are no closing ones. Remove all parentheses to get empty string.

Example 3 — Already Valid

$ Input: s = "()"

› Output: ["()"]

💡 Note: String is already valid, no removals needed. Return the original string.

Constraints

1 ≤ s.length ≤ 25
s consists of lowercase English letters and parentheses '(' and ')'
There will be at most 20 parentheses in s

Visualization

Tap to expand

Asked in

f Facebook 85 G Google 65 a Amazon 45 M Microsoft 35

The key insight is to use BFS to naturally find solutions with minimum removals first, or backtracking with pre-calculated removal counts for efficient pruning. Best approach is BFS for simplicity or backtracking for memory efficiency. Time: O(2^n), Space: O(2^n) for BFS, O(n) for backtracking.

Common Approaches

✓ BFS - Level by Level Removal

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

Use breadth-first search to generate strings by removing one parenthesis at a time. BFS naturally finds solutions with minimum removals first. Once we find valid strings at a level, we don't need to explore deeper levels.

Backtracking with Pruning

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

First calculate how many left and right parentheses need to be removed. Then use backtracking to try all valid combinations, pruning branches that exceed the required removals or lead to invalid states.

Brute Force - Try All Combinations

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

Try removing every possible combination of parentheses from the string. For each combination, check if the resulting string is valid. Keep track of the minimum number of removals and collect all valid strings with that minimum.

BFS - Level by Level Removal — Algorithm Steps

Start BFS with original string
For each level, try removing each parenthesis
Stop when first valid strings are found
Return all valid strings at that level

Visualization

Tap to expand

Step-by-Step Walkthrough

Level 0

Start with original string

Level 1

Remove one parenthesis at a time

Found

Stop when valid strings found

Code -

solution.c — C

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

#define MAX_QUEUE 10000
#define MAX_LEN 1000
#define MAX_VISITED 10000

static char visited_set[MAX_VISITED][MAX_LEN];
static int visited_count = 0;

bool is_visited(const char* str) {
    for (int i = 0; i < visited_count; i++) {
        if (strcmp(visited_set[i], str) == 0) {
            return true;
        }
    }
    return false;
}

void add_to_visited(const char* str) {
    if (visited_count < MAX_VISITED) {
        strcpy(visited_set[visited_count++], str);
    }
}

bool is_valid(const char* str) {
    int count = 0;
    for (int i = 0; str[i]; i++) {
        if (str[i] == '(') {
            count++;
        } else if (str[i] == ')') {
            count--;
            if (count < 0) {
                return false;
            }
        }
    }
    return count == 0;
}

char** solution(char* s, int* returnSize) {
    static char queue[MAX_QUEUE][MAX_LEN];
    static char level_results[MAX_QUEUE][MAX_LEN];
    int front = 0, rear = 0;
    char** results = (char**)malloc(1000 * sizeof(char*));
    int level_count = 0;
    
    visited_count = 0;
    strcpy(queue[rear++], s);
    add_to_visited(s);
    bool found = false;
    
    while (front < rear && !found) {
        int size = rear - front;
        level_count = 0;
        
        for (int i = 0; i < size; i++) {
            char* current = queue[front++];
            
            if (is_valid(current)) {
                // Check if already in level_results to avoid duplicates
                bool duplicate = false;
                for (int j = 0; j < level_count; j++) {
                    if (strcmp(level_results[j], current) == 0) {
                        duplicate = true;
                        break;
                    }
                }
                if (!duplicate) {
                    strcpy(level_results[level_count++], current);
                }
                found = true;
            }
            
            if (!found) {
                // Try removing each parenthesis
                for (int j = 0; current[j]; j++) {
                    if (current[j] == '(' || current[j] == ')') {
                        char next_string[MAX_LEN];
                        strncpy(next_string, current, j);
                        next_string[j] = '\0';
                        strcat(next_string, current + j + 1);
                        
                        if (!is_visited(next_string) && rear < MAX_QUEUE) {
                            add_to_visited(next_string);
                            strcpy(queue[rear++], next_string);
                        }
                    }
                }
            }
        }
    }
    
    if (found) {
        for (int i = 0; i < level_count; i++) {
            results[i] = (char*)malloc((strlen(level_results[i]) + 1) * sizeof(char));
            strcpy(results[i], level_results[i]);
        }
        *returnSize = level_count;
    } else {
        results[0] = (char*)malloc(2 * sizeof(char));
        strcpy(results[0], "");
        *returnSize = 1;
    }
    
    return results;
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    int returnSize;
    char** result = solution(s, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        if (i > 0) printf(",");
        printf("\"%s\"", result[i]);
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case, we still explore exponential combinations, but BFS pruning helps significantly

⚠ Quadratic Growth

Space Complexity

O(2^n)

BFS queue can contain exponential number of strings at each level

⚠ Quadratic Space

125.0K Views

High Frequency

~35 min Avg. Time

3.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

BFS - Level by Level Removal — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler