Remove Invalid Parentheses - Practice Coding Problems

Remove Invalid Parentheses - Problem

Remove Invalid Parentheses is a challenging string manipulation problem that tests your ability to find all valid solutions with minimal modifications.

Given a string s containing parentheses '(', ')' and letters, your task is to remove the minimum number of invalid parentheses to make the string valid. A valid string has properly matched and nested parentheses.

Key Requirements:

Remove the minimum number of parentheses
Return all unique valid strings possible
Letters can appear anywhere and should be preserved
Order of results doesn't matter

Example: "()())()" → ["()()()", "(())()"]

Both results remove exactly 1 parenthesis and create valid strings.

Input & Output

example_1.py — Basic Case

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

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

💡 Note: Remove the extra ')' at index 4. Two ways to form valid strings: remove it to get "()()()" or rearrange logic to see "(())()" is also possible with different removal.

example_2.py — Multiple Removals

$ Input: s = "((("

› Output: [""]

💡 Note: All parentheses are invalid '(' with no matching ')'. Must remove all 3 characters to get empty string, which is valid.

example_3.py — 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 ')'
The input string may contain letters that should be preserved
Return results in any order

Visualization

Tap to expand

Understanding the Visualization

Start Root

Begin with original string at root

Level 1

Try removing each parenthesis (one removal)

Check Validity

Test if any strings at current level are valid

Stop or Continue

If valid found, return results; else go deeper

Key Takeaway

🎯 Key Insight: BFS naturally finds minimum removals first, making it the optimal approach for this problem

Asked in

f Meta 45 G Google 38 a Amazon 32 ⊞ Microsoft 28

The optimal approach uses BFS (Breadth-First Search) to explore removal possibilities level by level. Start with the original string and systematically try removing each parenthesis. The key insight is that BFS naturally finds solutions with minimum removals first, so we can stop as soon as we find any valid strings. This guarantees optimality while being more efficient than brute force in practice.

Common Approaches

Approach	Time	Space	Notes
✓ BFS Level-by-Level (Optimal)	O(2^n)	O(2^n)	Use BFS to explore removals level by level, stopping at first valid solutions
Brute Force (Generate All Subsequences)	O(2^n × n)	O(2^n × n)	Generate all possible subsequences and check which ones are valid

BFS Level-by-Level (Optimal) — Algorithm Steps

Start BFS with the original string in queue
For each string, try removing each parenthesis character
Check if any string at current level is valid
If valid strings found, return them (minimum removals guaranteed)
Otherwise, continue to next level with longer removal sequences

Visualization

Tap to expand

Step-by-Step Walkthrough

Level 0

Start with original string

Level 1

Try removing each parenthesis

Check Validity

Stop when valid strings found

Return Results

All valid strings at first valid level

Code -

solution.c — C

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

#define MAX_QUEUE_SIZE 10000
#define MAX_STRING_LEN 100

bool isValid(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;
}

bool contains(char strings[][MAX_STRING_LEN], int count, char* str) {
    for (int i = 0; i < count; i++) {
        if (strcmp(strings[i], str) == 0) return true;
    }
    return false;
}

char** removeInvalidParentheses(char* s, int* returnSize) {
    if (isValid(s)) {
        char** result = (char**)malloc(sizeof(char*));
        result[0] = (char*)malloc((strlen(s) + 1) * sizeof(char));
        strcpy(result[0], s);
        *returnSize = 1;
        return result;
    }
    
    char queue[MAX_QUEUE_SIZE][MAX_STRING_LEN];
    char visited[MAX_QUEUE_SIZE][MAX_STRING_LEN];
    char results[MAX_QUEUE_SIZE][MAX_STRING_LEN];
    
    int queueFront = 0, queueRear = 0;
    int visitedCount = 0;
    int resultCount = 0;
    
    strcpy(queue[queueRear++], s);
    strcpy(visited[visitedCount++], s);
    
    while (queueFront < queueRear && resultCount == 0) {
        int levelSize = queueRear - queueFront;
        char levelVisited[MAX_QUEUE_SIZE][MAX_STRING_LEN];
        int levelVisitedCount = 0;
        
        for (int i = 0; i < levelSize; i++) {
            char current[MAX_STRING_LEN];
            strcpy(current, queue[queueFront++]);
            
            for (int j = 0; current[j]; j++) {
                if (current[j] == '(' || current[j] == ')') {
                    char nextString[MAX_STRING_LEN];
                    strncpy(nextString, current, j);
                    strcpy(nextString + j, current + j + 1);
                    
                    if (isValid(nextString)) {
                        if (!contains(results, resultCount, nextString)) {
                            strcpy(results[resultCount++], nextString);
                        }
                    }
                    
                    if (!contains(visited, visitedCount, nextString) && 
                        !contains(levelVisited, levelVisitedCount, nextString)) {
                        strcpy(levelVisited[levelVisitedCount++], nextString);
                        strcpy(queue[queueRear++], nextString);
                    }
                }
            }
        }
        
        for (int i = 0; i < levelVisitedCount; i++) {
            strcpy(visited[visitedCount++], levelVisited[i]);
        }
    }
    
    if (resultCount == 0) {
        char** result = (char**)malloc(sizeof(char*));
        result[0] = (char*)malloc(1);
        result[0][0] = '\0';
        *returnSize = 1;
        return result;
    }
    
    char** result = (char**)malloc(resultCount * sizeof(char*));
    for (int i = 0; i < resultCount; i++) {
        result[i] = (char*)malloc((strlen(results[i]) + 1) * sizeof(char));
        strcpy(result[i], results[i]);
    }
    
    *returnSize = resultCount;
    return result;
}

int main() {
    char s[MAX_STRING_LEN];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    if (s[0] == '"') {
        int len = strlen(s);
        for (int i = 1; i < len - 1; i++) {
            s[i-1] = s[i];
        }
        s[len-2] = '\0';
    }
    
    int returnSize;
    char** result = removeInvalidParentheses(s, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("\"%s\"", result[i]);
        if (i < returnSize - 1) printf(", ");
        free(result[i]);
    }
    printf("]\n");
    free(result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

In worst case, explores all possible removal combinations

⚠ Quadratic Growth

Space Complexity

O(2^n)

Queue can store exponential number of strings in worst case

⚠ Quadratic Space

52.3K Views

High Frequency

~25 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

BFS Level-by-Level (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler