Minimum Add to Make Parentheses Valid - Practice Coding Problems

Minimum Add to Make Parentheses Valid - Problem

Imagine you're a code editor that needs to automatically balance parentheses in user code. You have a string containing only '(' and ')' characters, but some parentheses are missing!

A valid parentheses string follows these rules:

It's either an empty string
It can be written as AB where both A and B are valid
It can be written as (A) where A is valid

Your mission: Find the minimum number of parentheses you need to insert anywhere in the string to make it perfectly balanced.

For example, if you have "())", you could insert one opening parenthesis at the beginning to get "(())" - that's just 1 insertion!

Input & Output

example_1.py — Basic Case

$ Input: s = "())"

› Output: 1

💡 Note: We have one unmatched closing parenthesis. We need to add one opening parenthesis at the beginning: "(())" to make it valid.

example_2.py — Multiple Unmatched

$ Input: s = "((("

› Output: 3

💡 Note: We have three unmatched opening parentheses. We need to add three closing parentheses at the end: "((()))" to make it valid.

example_3.py — Mixed Unmatched

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

› Output: 1

💡 Note: The first ')' has no matching '(' before it, so we need to add one opening parenthesis. Result: "(())()" requires 1 addition.

Constraints

1 ≤ s.length ≤ 1000
s[i] is either '(' or ')'
Note: The string contains only parentheses characters

Visualization

Tap to expand

Understanding the Visualization

Initialize Counters

Start with unmatched_open = 0, unmatched_close = 0

Process Opening '('

Increment unmatched_open counter (add plate to stack)

Process Closing ')'

If unmatched_open > 0, decrement it (remove plate); otherwise increment unmatched_close

Calculate Result

Return unmatched_open + unmatched_close (plates + missing covers)

Key Takeaway

🎯 Key Insight: We only need to track two types of errors: closing parentheses that appear without a matching opening one (need to add opening), and opening parentheses that never get closed (need to add closing). A single pass with two counters captures both cases optimally.

Asked in

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

The optimal solution uses a greedy single-pass approach with two counters: one for unmatched opening parentheses and one for unmatched closing parentheses. As we scan the string, we match closing brackets with available opening ones, and count any that remain unmatched. The final answer is the sum of both unmatched counters, achieving O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(3^n)	O(3^n)	Generate all possible ways to insert parentheses and check validity
Greedy Single Pass (Optimal)	O(n)	O(1)	Track unmatched parentheses in one pass through the string

Brute Force (Try All Combinations) — Algorithm Steps

Start with 1 insertion and try all positions and types
Generate all possible strings with 1 insertion
Check if any generated string is valid
If not found, increment insertion count and repeat
Return the minimum number when valid string found

Visualization

Tap to expand

Step-by-Step Walkthrough

Try 1 insertion

Test inserting '(' or ')' at each position

Check validity

Verify if the resulting string is balanced

Increment count

If no valid string found, try 2 insertions

Code -

solution.c — C

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

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

bool backtrack(int pos, char* currentString, int remainingInsertions) {
    if (remainingInsertions == 0) {
        return isValid(currentString);
    }
    
    int len = strlen(currentString);
    if (pos > len) return false;
    
    // Try inserting '('
    char* newString = malloc(len + 2);
    strncpy(newString, currentString, pos);
    newString[pos] = '(';
    strcpy(newString + pos + 1, currentString + pos);
    
    if (backtrack(pos + 1, newString, remainingInsertions - 1)) {
        free(newString);
        return true;
    }
    free(newString);
    
    // Try inserting ')'
    newString = malloc(len + 2);
    strncpy(newString, currentString, pos);
    newString[pos] = ')';
    strcpy(newString + pos + 1, currentString + pos);
    
    if (backtrack(pos + 1, newString, remainingInsertions - 1)) {
        free(newString);
        return true;
    }
    free(newString);
    
    // Don't insert anything
    if (backtrack(pos + 1, currentString, remainingInsertions)) {
        return true;
    }
    
    return false;
}

int minAddToMakeValid(char* s) {
    if (isValid(s)) return 0;
    
    int len = strlen(s);
    for (int insertions = 1; insertions <= len + 2; insertions++) {
        if (backtrack(0, s, insertions)) {
            return insertions;
        }
    }
    return len;
}

int main() {
    char s[1001];
    scanf("%s", s);
    // Remove quotes if present
    if (s[0] == '"') {
        memmove(s, s + 1, strlen(s));
        s[strlen(s) - 1] = '\0';
    }
    printf("%d\n", minAddToMakeValid(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

For each position, we can insert '(', ')' or nothing, leading to exponential combinations

✓ Linear Growth

Space Complexity

O(3^n)

Need to store all possible generated strings

⚡ Linearithmic Space

68.2K Views

Medium Frequency

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