Minimum Insertions to Balance a Parentheses String

Minimum Insertions to Balance a Parentheses String - Problem

Given a parentheses string s containing only the characters '(' and ')'. A parentheses string is balanced if:

Any left parenthesis '(' must have a corresponding two consecutive right parenthesis '))'.
Left parenthesis '(' must go before the corresponding two consecutive right parenthesis '))'.

In other words, we treat '(' as an opening parenthesis and '))' as a closing parenthesis.

For example, "())", "())(()))" and "(())()))" are balanced, ")()", "()))" and "(()))" are not balanced.

You can insert the characters '(' and ')' at any position of the string to balance it if needed.

Return the minimum number of insertions needed to make s balanced.

Input & Output

Example 1 — Basic Unbalanced

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

› Output: 1

💡 Note: We have "(()))" which has one '(' needing two ')', but there are three ')'. The second and third ')' form a valid pair ')', but the last ')' is unmatched. We need to insert one ')' to make it "(()))".

Example 2 — Multiple Opens

$ Input: s = "((("

› Output: 6

💡 Note: We have 3 opening parentheses, each needing 2 closing parentheses. So we need 3 × 2 = 6 insertions: "(((" → "((())))".

Example 3 — Mixed Case

$ Input: s = "())("

› Output: 2

💡 Note: "())" is balanced (one '(' with ')'), but we have an extra ')' and an unmatched '(' at the end. Need to insert one '(' for the extra ')' and two ')' for the final '('.

Constraints

1 ≤ s.length ≤ 10⁵
s consists of only '(' and ')'

Visualization

Tap to expand

Asked in

F Facebook 45 G Google 38 M Microsoft 32 a Amazon 28

The key insight is that each '(' needs exactly two ')' characters to balance. The optimal approach uses a greedy strategy tracking the running deficit of needed closing parentheses. Best approach: Greedy Balance Tracking - Time: O(n), Space: O(1).

Common Approaches

✓ Greedy Balance Tracking

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

Maintain a running balance of opens vs needed closes. When we see '(', we need 2 closes. When we see ')', we can satisfy one needed close. Insert characters as needed to maintain balance.

Recursive Try All Insertions

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

Generate all possible strings by inserting '(' and ')' at every position, check if balanced, and return minimum insertions needed. This explores the entire solution space.

Stack-Based Tracking

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

Traverse the string and use a counter to track unmatched opening parentheses. For each closing parenthesis, try to form pairs of ')) and handle remaining characters at the end.

Greedy Balance Tracking — Algorithm Steps

Track needed closing parentheses (start with 0)
For '(': add 2 to needed count
For ')': if needed > 0, decrement; else insert '(' and add 1 to needed
Return total insertions

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Opens

Each '(' adds 2 to needed count

Process Closes

Each ')' reduces needed or triggers insertion

Final Balance

Add remaining needed closes

Code -

solution.c — C

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

int solution(const char* s) {
    int insertions = 0;
    int needed = 0;
    int len = strlen(s);
    
    for (int i = 0; i < len; i++) {
        if (s[i] == '(') {
            needed += 2;
        } else {
            if (needed > 0) {
                needed -= 1;
            } else {
                insertions += 1;
                needed += 1;
            }
        }
    }
    
    insertions += needed;
    
    return insertions;
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string processing each character once

✓ Linear Growth

Space Complexity

O(1)

Only using two integer variables for tracking

⚡ Linearithmic Space

87.5K Views

Medium 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Greedy Balance Tracking — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler