Minimum Number of Swaps to Make the String Balanced

Minimum Number of Swaps to Make the String Balanced - Problem

🎯 Minimum Number of Swaps to Make the String Balanced

You are given a string s consisting of exactly n/2 opening brackets '[' and n/2 closing brackets ']', where n is the even length of the string.

A string is considered balanced if:

It is the empty string, or
It can be written as AB, where both A and B are balanced strings, or
It can be written as [C], where C is a balanced string.

Example: "[[]]" is balanced, but "]]][" is not balanced.

You can swap any two brackets at any positions any number of times. Your goal is to find the minimum number of swaps needed to make the string balanced.

Key Insight: Since we have equal numbers of opening and closing brackets, we only need to fix the misplaced closing brackets that appear before their matching opening brackets.

Input & Output

example_1.py — Basic unbalanced string

$ Input: s = "][]["

› Output: 1

💡 Note: You can make the string balanced by swapping index 0 with index 1 to get "[]", or swap index 0 with index 3 to get "[]]][[" then swap index 1 with index 2 to get "[[]]".

example_2.py — Already balanced

$ Input: s = "[]"

› Output: 0

💡 Note: The string is already balanced, so no swaps are needed.

example_3.py — Complex case

$ Input: s = "]]]][[[["

› Output: 2

💡 Note: We have 4 unmatched closing brackets at the beginning. We can fix 2 unmatched closing brackets with 1 swap, so we need 2 swaps total: ceil(4/2) = 2.

Constraints

n == s.length
2 ≤ n ≤ 10⁶
n is even
s[i] is either '[' or ']'
The number of opening brackets '[' equals the number of closing brackets ']'

Visualization

Tap to expand

Understanding the Visualization

Initialize Balance

Start with balance = 0, like an empty bank account

Process Brackets

Opening brackets add 1, closing brackets subtract 1 from balance

Track Debt

When balance goes negative, count the 'debt' and reset balance to 0

Calculate Swaps

Each swap fixes 2 units of debt, so swaps = ceil(debt / 2)

Key Takeaway

🎯 Key Insight: Track the running balance of brackets - when it goes negative, we have unmatched closing brackets that need swapping. Each swap fixes exactly 2 unmatched brackets.

Asked in

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

The optimal solution uses a stack-based balance tracking approach. We traverse the string once, tracking unmatched closing brackets that appear before their corresponding opening brackets. The key insight is that each swap can fix exactly 2 unmatched closing brackets, so the minimum swaps needed is ceil(unmatched_closing_brackets / 2). This gives us O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Swaps)	O(n! × n)	O(n)	Try all possible swaps until string becomes balanced
Stack-based Balance Tracking	O(n)	O(1)	Use stack concept to track unmatched closing brackets

Brute Force (Try All Swaps) — Algorithm Steps

Generate all possible pairs of positions to swap
For each swap combination, create new string
Check if the resulting string is balanced
Track minimum swaps needed among all valid arrangements

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Start with unbalanced string

Try All Swaps

Systematically try swapping every pair of different brackets

Check Balance

For each swap, verify if string becomes balanced

Track Minimum

Keep track of minimum swaps needed

Code -

solution.c — C

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

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

int generateSwaps(char* s, int swaps) {
    if (isBalanced(s)) return swaps;
    
    int minSwaps = INT_MAX;
    int len = strlen(s);
    
    for (int i = 0; i < len; i++) {
        for (int j = i + 1; j < len; j++) {
            if (s[i] != s[j]) {
                char temp = s[i];
                s[i] = s[j];
                s[j] = temp;
                
                int result = generateSwaps(s, swaps + 1);
                if (result < minSwaps) {
                    minSwaps = result;
                }
                
                s[j] = s[i];
                s[i] = temp;
            }
        }
    }
    return minSwaps;
}

int minSwaps(char* s) {
    return generateSwaps(s, 0);
}

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

Time & Space Complexity

Time Complexity

⏱️

O(n! × n)

n! possible arrangements multiplied by O(n) to check if balanced

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing string copies and recursion stack

⚡ Linearithmic Space

52.8K Views

High Frequency

~15 min Avg. Time

2.1K 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

🎯 Minimum Number of Swaps to Make the String Balanced

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Swaps) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler