Minimum Insertions to Balance a Parentheses String

Minimum Insertions to Balance a Parentheses String - Problem

The Balance Challenge

Imagine you're working with a special parentheses system where the rules are slightly different from traditional parentheses. In this system:

Every opening parenthesis '(' must be matched with exactly two consecutive closing parentheses '))'
The opening parenthesis must come before its matching closing pair

Examples of balanced strings:

"())" - One opening, two closing
"())(()))" - Two complete pairs
"(())()))" - Nested and sequential pairs

Examples of unbalanced strings:

")()" - Closing before opening
"()))" - Missing opening parenthesis
"(()))" - Missing one closing parenthesis

Your task is to find the minimum number of insertions needed to make any given parentheses string balanced according to these rules.

Input & Output

example_1.py — Basic Case

$ Input: s = "())"

› Output: 1

💡 Note: We have one '(' that needs to be matched with '))', but we only have one ')'. We need to insert one more ')' at the end to make it "()))" which is balanced.

example_2.py — Multiple Pairs

$ Input: s = "((("

› Output: 6

💡 Note: We have three unmatched '(' characters. Each needs to be matched with '))', so we need to insert 3 × 2 = 6 closing parentheses to get "((())))"

example_3.py — Mixed Case

$ Input: s = "()))"

› Output: 1

💡 Note: The first ')' doesn't have a matching '(' before it, and the ')))' forms one valid pair. We need to insert one '(' at the beginning to make "(()))" which is balanced.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of '(' and ')' only
Each '(' must be matched with exactly two consecutive ')'

Visualization

Tap to expand

Understanding the Visualization

Collect Locks

When we see '(', we add it to our collection of unmatched locks

Use Key Pairs

When we see '))', we try to use it to open a lock from our collection

Handle Single Keys

When we see single ')', we need to get another key and then use the pair

Final Matching

Any remaining locks need their key pairs manufactured

Key Takeaway

🎯 Key Insight: By processing characters from left to right and maintaining a count of unmatched opening parentheses, we can determine the minimum insertions needed in a single pass. The greedy approach works because we can always make locally optimal decisions about when to match or insert parentheses.

Asked in

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

The optimal solution uses a greedy one-pass approach that tracks unmatched opening parentheses while processing closing parentheses in pairs. Key insight: each '(' needs exactly '))' to be balanced, so we handle single ')' by inserting the missing pair and ')' pairs by matching with available openings.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Recursive Exploration)	O(3^n)	O(n)	Try all possible ways to insert parentheses and find the minimum
One-Pass Greedy (Optimal)	O(n)	O(1)	Track unmatched opening parentheses and handle closing pairs greedily in one pass

Brute Force (Recursive Exploration) — Algorithm Steps

For each position in the string, try inserting '(' or '))'
Recursively check if the resulting string can be balanced
Keep track of the minimum insertions found so far
Return the minimum across all possibilities

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial String

Start with the given string and explore all insertion possibilities

Branch Creation

At each position, create branches for inserting '(' and ')'

Recursive Exploration

Continue branching until a balanced string is found

Minimum Selection

Return the path with minimum insertions

Code -

solution.c — C

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

int isBalanced(char* str) {
    int openCount = 0;
    int i = 0;
    int len = strlen(str);
    
    while (i < len) {
        if (str[i] == '(') {
            openCount++;
        } else if (str[i] == ')') {
            if (i + 1 < len && str[i + 1] == ')') {
                if (openCount > 0) {
                    openCount--;
                } else {
                    return 0;
                }
                i++;
            } else {
                return 0;
            }
        }
        i++;
    }
    return openCount == 0;
}

int solve(char* str, int insertions) {
    if (isBalanced(str)) {
        return insertions;
    }
    
    if (insertions > strlen(str)) {
        return INT_MAX;
    }
    
    int minInsertions = INT_MAX;
    int len = strlen(str);
    
    for (int i = 0; i <= len; i++) {
        char* newStr = (char*)malloc(len + 2);
        strncpy(newStr, str, i);
        newStr[i] = '(';
        strcpy(newStr + i + 1, str + i);
        
        int result = solve(newStr, insertions + 1);
        if (result < minInsertions) {
            minInsertions = result;
        }
        free(newStr);
        
        newStr = (char*)malloc(len + 2);
        strncpy(newStr, str, i);
        newStr[i] = ')';
        strcpy(newStr + i + 1, str + i);
        
        result = solve(newStr, insertions + 1);
        if (result < minInsertions) {
            minInsertions = result;
        }
        free(newStr);
    }
    
    return minInsertions;
}

int main() {
    char s[1000];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    printf("%d\n", solve(s, 0));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(3^n)

At each position, we can insert '(', ')' or nothing, leading to exponential branching

✓ Linear Growth

Space Complexity

O(n)

Recursion stack depth proportional to string length

⚡ Linearithmic Space

52.3K Views

Medium-High Frequency

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

The Balance Challenge

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Recursive Exploration) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler