Minimum Remove to Make Valid Parentheses

Minimum Remove to Make Valid Parentheses - Problem

String Stack Medium

Given a string s containing '(', ')' and lowercase English characters, your task is to remove the minimum number of parentheses to make the resulting string valid.

A valid parentheses string is defined as:

The empty string, or contains only lowercase characters
It can be written as AB (A concatenated with B), where A and B are valid strings
It can be written as (A), where A is a valid string

Return any valid string after removing the minimum number of parentheses.

Input & Output

Example 1 — Extra Closing Parenthesis

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

› Output: "()()"

💡 Note: Remove the extra closing parenthesis at position 4. The string "()()" has valid balanced parentheses.

Example 2 — Extra Opening Parenthesis

$ Input: s = "((("

› Output: ""

💡 Note: All three opening parentheses are unmatched, so remove all of them to get empty string.

Example 3 — Mixed with Letters

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

› Output: "(a)b"

💡 Note: Remove one closing parenthesis after 'a' and the closing parenthesis after 'b' to make it valid.

Constraints

1 ≤ s.length ≤ 10⁵
s[i] is either '(' , ')' or lowercase English letter

Visualization

Tap to expand

Asked in

f Facebook 65 G Google 45 a Amazon 38

The key insight is to use a two-pass approach to identify and remove unmatched parentheses. The optimal solution uses counters to track unmatched brackets without extra space. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force - Try All Combinations

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

Try removing every possible combination of parentheses from the string. For each combination, check if the resulting string has valid parentheses. Return the first valid string found with maximum length.

Stack-Based Approach

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

Use a stack to keep track of indices of unmatched opening parentheses. Mark all unmatched opening and closing parentheses for removal, then build the result string.

Two-Pass Optimal

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

First pass counts how many closing brackets don't have matching opening brackets. Second pass removes these unmatched closing brackets and excess opening brackets from the end.

Brute Force - Try All Combinations — Algorithm Steps

Generate all possible subsequences by including/excluding each parenthesis
For each subsequence, check if parentheses are balanced
Return the longest valid subsequence found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate

Create all possible subsequences

Validate

Check if parentheses are balanced

Select

Return longest valid subsequence

Code -

solution.c — C

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

int isValid(char* s) {
    int count = 0;
    for (int i = 0; s[i]; i++) {
        if (s[i] == '(') {
            count++;
        } else if (s[i] == ')') {
            count--;
            if (count < 0) return 0;
        }
    }
    return count == 0;
}

char* generateSubsequences(char* s, int index, char* current, int currentLen) {
    if (index == strlen(s)) {
        if (isValid(current)) {
            char* result = malloc(strlen(current) + 1);
            strcpy(result, current);
            return result;
        }
        return strdup("");
    }
    
    current[currentLen] = s[index];
    current[currentLen + 1] = '\0';
    char* result1 = generateSubsequences(s, index + 1, current, currentLen + 1);
    
    char* result2 = strdup("");
    if (s[index] == '(' || s[index] == ')') {
        current[currentLen] = '\0';
        result2 = generateSubsequences(s, index + 1, current, currentLen);
    }
    
    if (strlen(result1) >= strlen(result2)) {
        free(result2);
        return result1;
    }
    free(result1);
    return result2;
}

char* solution(char* s) {
    char* current = malloc(strlen(s) + 1);
    current[0] = '\0';
    char* result = generateSubsequences(s, 0, current, 0);
    free(current);
    return result;
}

int main() {
    char s[100001];
    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^n)

Generate 2^n subsequences where n is string length

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth and string storage

✓ Linear Space

85.4K Views

High Frequency

~15 min Avg. Time

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

Brute Force - Try All Combinations — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler