Minimum Number of Swaps to Make the String Balanced

Minimum Number of Swaps to Make the String Balanced - Problem

You are given a 0-indexed string s of even length n. The string consists of exactly n / 2 opening brackets '[' and n / 2 closing brackets ']'.

A string is called balanced if and only 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.

You may swap the brackets at any two indices any number of times.

Return the minimum number of swaps to make s balanced.

Input & Output

Example 1 — Basic Unbalanced Case

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

› Output: 2

💡 Note: We have 3 closing brackets followed by 3 opening brackets. Need 2 swaps: swap positions 0,3 and 1,4 to get "[[][]]" which is balanced.

Example 2 — Already Balanced

$ Input: s = "[]"

› Output: 0

💡 Note: String is already balanced with proper opening and closing bracket pairs, so no swaps needed.

Example 3 — Mixed Pattern

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

› Output: 2

💡 Note: We have 3 closing brackets followed by 3 opening brackets, same as Example 1. Need 2 swaps to balance the string.

Constraints

2 ≤ s.length ≤ 10⁶
s.length is even
s consists of exactly s.length/2 opening brackets '[' and s.length/2 closing brackets ']'

Visualization

Tap to expand

Asked in

f Facebook 15 A Amazon 12 M Microsoft 8

The key insight is that each swap fixes exactly 2 unmatched brackets. By tracking the running balance and counting excess closing brackets, we can calculate the minimum swaps as (unmatched + 1) / 2. Best approach is greedy balance tracking. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Try All Swaps

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

Generate all possible swap combinations and check if the resulting string is balanced. Keep track of minimum swaps needed.

Greedy - Count Unmatched Brackets

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

Traverse string left to right, maintaining a balance counter. When balance goes negative, we have excess closing brackets that need swaps.

Brute Force - Try All Swaps — Algorithm Steps

Step 1: Generate all possible ways to swap brackets
Step 2: For each combination, check if string is balanced
Step 3: Return minimum swaps among valid combinations

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Swaps

Try swapping every pair of different brackets

Check Balance

Test if resulting string is balanced

Find Minimum

Return smallest number of swaps that work

Code -

solution.c — C

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

static char queue[100000][21];  // Static allocation for queue
static int swaps_queue[100000];
static char visited[100000][21];
static int queue_size = 0;
static int visited_count = 0;

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

int isVisited(const char* str) {
    for (int i = 0; i < visited_count; i++) {
        if (strcmp(visited[i], str) == 0) {
            return 1;
        }
    }
    return 0;
}

void addVisited(const char* str) {
    strcpy(visited[visited_count], str);
    visited_count++;
}

int solution(char* s) {
    if (isBalanced(s)) return 0;
    
    // Initialize BFS
    strcpy(queue[0], s);
    swaps_queue[0] = 0;
    queue_size = 1;
    
    addVisited(s);
    
    int front = 0;
    
    while (front < queue_size) {
        char current[21];
        strcpy(current, queue[front]);
        int current_swaps = swaps_queue[front];
        front++;
        
        int len = strlen(current);
        
        // Try all possible swaps
        for (int i = 0; i < len; i++) {
            for (int j = i + 1; j < len; j++) {
                if (current[i] != current[j]) {  // Only swap different characters
                    char temp = current[i];
                    current[i] = current[j];
                    current[j] = temp;
                    
                    if (isBalanced(current)) {
                        return current_swaps + 1;
                    }
                    
                    if (!isVisited(current)) {
                        addVisited(current);
                        strcpy(queue[queue_size], current);
                        swaps_queue[queue_size] = current_swaps + 1;
                        queue_size++;
                    }
                    
                    // backtrack
                    temp = current[i];
                    current[i] = current[j];
                    current[j] = temp;
                }
            }
        }
    }
    
    return -1;  // Should never reach here
}

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

Time & Space Complexity

Time Complexity

⏱️

O(2^n)

Need to try exponentially many swap combinations

⚠ Quadratic Growth

Space Complexity

O(n)

Stack space for recursion and string copies

⚡ Linearithmic Space

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

Brute Force - Try All Swaps — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler