 Open in App
Not now

# Minimum Swaps for Bracket Balancing

• Difficulty Level : Medium
• Last Updated : 12 Jan, 2023

You are given a string of 2N characters consisting of N ‘[‘ brackets and N ‘]’ brackets. A string is considered balanced if it can be represented in the form S2[S1] where S1 and S2 are balanced strings. We can make an unbalanced string balanced by swapping adjacent characters. Calculate the minimum number of swaps necessary to make a string balanced.

Examples:

```Input  : []][][
Output : 2
First swap: Position 3 and 4
[][]][
Second swap: Position 5 and 6
[][][]

Input  : [[][]]
Output : 0

We can solve this problem by using greedy strategies. If the first X characters form a balanced string, we can neglect these characters and continue on. If we encounter a ‘]’ before the required ‘[‘, then we must start swapping elements to balance the string.

Naive Approach
Initialize sum = 0 where sum stores result. Go through the string maintaining a count of the number of ‘[‘ brackets encountered. Reduce this count when we encounter a ‘]’ character. If the count hits negative, then we must start balancing the string.
Let index ‘i’ represent the position we are at. We now move forward to the next ‘[‘ at index j. Increase sum by j – i. Move the ‘[‘ at position j, to position i, and shift all other characters to the right. Set the count back to 1 and continue traversing the string. In the end, ‘sum’ will have the required value.

Time Complexity = O(N^2)
Extra Space = O(1)

Optimized approach
We can initially go through the string and store the positions of ‘[‘ in a vector say ‘pos‘. Initialize ‘p’ to 0. We shall use p to traverse the vector ‘pos’. Similar to the naive approach, we maintain a count of encountered ‘[‘ brackets. When we encounter a ‘[‘ we increase the count and increase ‘p’ by 1. When we encounter a ‘]’ we decrease the count. If the count ever goes negative, this means we must start swapping. The element pos[p] tells us the index of the next ‘[‘. We increase the sum by pos[p] – i, where i is the current index. We can swap the elements in the current index and pos[p] and reset the count to 0 and increment p so that it pos[p] indicates to the next ‘[‘.
Since we have converted a step that was O(N) in the naive approach, to an O(1) step, our new time complexity reduces.

Time Complexity = O(N)
Extra Space = O(N)

## C++

 `// C++ program to count swaps required to balance string` `#include ` `#include ` `#include ` `using` `namespace` `std;`   `// Function to calculate swaps required` `long` `swapCount(string s)` `{` `    ``// Keep track of '['` `    ``vector<``int``> pos;` `    ``for` `(``int` `i = 0; i < s.length(); ++i)` `        ``if` `(s[i] == ``'['``)` `            ``pos.push_back(i);`   `    ``int` `count = 0; ``// To count number of encountered '['` `    ``int` `p = 0;  ``// To track position of next '[' in pos` `    ``long` `sum = 0; ``// To store result`   `    ``for` `(``int` `i = 0; i < s.length(); ++i)` `    ``{` `        ``// Increment count and move p to next position` `        ``if` `(s[i] == ``'['``)` `        ``{` `            ``++count;` `            ``++p;` `        ``}` `        ``else` `if` `(s[i] == ``']'``)` `            ``--count;`   `        ``// We have encountered an unbalanced part of string` `        ``if` `(count < 0)` `        ``{` `            ``// Increment sum by number of swaps required` `            ``// i.e. position of next '[' - current position` `            ``sum += pos[p] - i;` `            ``swap(s[i], s[pos[p]]);` `            ``++p;`   `            ``// Reset count to 1` `            ``count = 1;` `        ``}` `    ``}` `    ``return` `sum;` `}`   `// Driver code` `int` `main()` `{` `    ``string s = ``"[]][]["``;` `    ``cout << swapCount(s) << ``"\n"``;`   `    ``s = ``"[[][]]"``;` `    ``cout << swapCount(s) << ``"\n"``;` `    ``return` `0;` `}`

## Java

 `// Java program to count swaps ` `// required to balance string` `import` `java.util.*;`   `class` `GFG{` `    `  `// Function to calculate swaps required` `public` `static` `long` `swapCount(String s)` `{` `    `  `    ``// Keep track of '['` `    ``Vector pos = ``new` `Vector(); ` `    ``for``(``int` `i = ``0``; i < s.length(); ++i)` `        ``if` `(s.charAt(i) == ``'['``)` `            ``pos.add(i);` `            `  `    ``// To count number of encountered '['` `    ``int` `count = ``0``; ` `    `  `    ``// To track position of next '[' in pos` `    ``int` `p = ``0``;  ` `    `  `    ``// To store result` `    ``long` `sum = ``0``; ` `    `  `    ``char``[] S = s.toCharArray(); ` `    `  `    ``for``(``int` `i = ``0``; i < s.length(); ++i)` `    ``{` `        `  `        ``// Increment count and move p ` `        ``// to next position` `        ``if` `(S[i] == ``'['``)` `        ``{` `            ``++count;` `            ``++p;` `        ``}` `        ``else` `if` `(S[i] == ``']'``)` `            ``--count;` ` `  `        ``// We have encountered an ` `        ``// unbalanced part of string` `        ``if` `(count < ``0``)` `        ``{` `            `  `            ``// Increment sum by number of ` `            ``// swaps required i.e. position ` `            ``// of next '[' - current position` `            ``sum += pos.get(p) - i;` `            ``char` `temp = S[i];` `            ``S[i] = S[pos.get(p)];` `            ``S[pos.get(p)] = temp;` `            ``++p;` ` `  `            ``// Reset count to 1` `            ``count = ``1``;` `        ``}` `    ``}` `    ``return` `sum;` `}`   `// Driver code` `public` `static` `void` `main(String[] args) ` `{` `    ``String s = ``"[]][]["``;` `    ``System.out.println(swapCount(s));` ` `  `    ``s = ``"[[][]]"``;` `    ``System.out.println(swapCount(s));` `}` `}`   `// This code is contributed by divyesh072019`

## Python3

 `# Python3 Program to count ` `# swaps required to balance ` `# string `   `# Function to calculate ` `# swaps required ` `def` `swapCount(s):`   `    ``# Keep track of '[' ` `    ``pos ``=` `[]`   `    ``for` `i ``in` `range``(``len``(s)):` `        ``if``(s[i] ``=``=` `'['``):` `            ``pos.append(i)`   `    ``# To count number ` `    ``# of encountered '['         ` `    ``count ``=` `0` `    `  `    ``# To track position ` `    ``# of next '[' in pos ` `    ``p ``=` `0`    `    `  `    ``# To store result ` `    ``sum` `=` `0`        `    ``s ``=` `list``(s)` `    `  `    ``for` `i ``in` `range``(``len``(s)):`   `        ``# Increment count and ` `        ``# move p to next position ` `        ``if``(s[i] ``=``=` `'['``):` `            ``count ``+``=` `1` `            ``p ``+``=` `1` `        ``elif``(s[i] ``=``=` `']'``):` `            ``count ``-``=` `1`   `        ``# We have encountered an ` `        ``# unbalanced part of string ` `        ``if``(count < ``0``):` `          `  `            ``# Increment sum by number ` `            ``# of swaps required ` `            ``# i.e. position of next ` `            ``# '[' - current position ` `            ``sum` `+``=` `pos[p] ``-` `i` `            ``s[i], s[pos[p]] ``=` `(s[pos[p]], ` `                               ``s[i])` `            ``p ``+``=` `1`   `            ``# Reset count to 1 ` `            ``count ``=` `1` `    ``return` `sum`   `# Driver code ` `s ``=` `"[]][]["` `print``(swapCount(s))`   `s ``=` `"[[][]]"` `print``(swapCount(s))`   `# This code is contributed by avanitrachhadiya2155`

## C#

 `// C# program to count swaps ` `// required to balance string` `using` `System.IO;` `using` `System;` `using` `System.Collections;` `using` `System.Collections.Generic;`   `class` `GFG{`   `// Function to calculate swaps required` `static` `long` `swapCount(``string` `s)` `{` `    `  `    ``// Keep track of '['` `    ``List<``int``> pos = ``new` `List<``int``>();` `    ``for``(``int` `i = 0; i < s.Length; i++)` `    ``{` `        ``if` `(s[i] == ``'['``)` `        ``{` `            ``pos.Add(i);` `        ``}` `    ``}` `    `  `    ``// To count number of encountered '['` `    ``int` `count = 0;` `    `  `    ``// To track position of next '[' in pos` `    ``int` `p = 0;` `    `  `    ``// To store result` `    ``long` `sum = 0;` `    `  `    ``char``[] S = s.ToCharArray();` `    `  `    ``for``(``int` `i = 0; i < S.Length; i++)` `    ``{` `        `  `        ``// Increment count and move p ` `        ``// to next position` `        ``if` `(S[i] == ``'['``)` `        ``{` `            ``++count;` `            ``++p;` `        ``}` `        ``else` `if` `(S[i] == ``']'``)` `        ``{` `            ``--count;` `        ``}` `        `  `        ``// We have encountered an ` `        ``// unbalanced part of string` `        ``if` `(count < 0)` `        ``{` `            `  `            ``// Increment sum by number of ` `            ``// swaps required i.e. position ` `            ``// of next '[' - current position` `            ``sum += pos[p]-i;` `            ``char` `temp = S[i];` `            ``S[i] = S[pos[p]];` `            ``S[pos[p]] = temp;` `            ``++p;` `            `  `            ``// Reset count to 1` `            ``count = 1;` `        ``}` `    ``}` `    ``return` `sum;` `}`   `// Driver code` `static` `void` `Main()` `{` `    ``string` `s = ``"[]][]["``;` `    ``Console.WriteLine(swapCount(s));` `    `  `    ``s = ``"[[][]]"``;` `    ``Console.WriteLine(swapCount(s));` `}` `}`   `// This code is contributed by rag2127`

## Javascript

 ``

Output

```2
0```

Time Complexity: O(N)
Auxiliary Space: O(N)

Another Method:
We can do without having to store the positions of ‘[‘.

Below is the implementation :

## C++

 `// C++ program to count swaps required ` `// to balance string` `#include ` `using` `namespace` `std;`   `long` `swapCount(string chars) ` `{` `    `  `    ``// Stores total number of Left and ` `    ``// Right brackets encountered` `    ``int` `countLeft = 0, countRight = 0; ` `    `  `    ``// swap stores the number of swaps ` `    ``// required imbalance maintains ` `    ``// the number of imbalance pair` `    ``int` `swap = 0 , imbalance = 0; ` `     `  `    ``for``(``int` `i = 0; i < chars.length(); i++) ` `    ``{` `        ``if` `(chars[i] == ``'['``) ` `        ``{` `            `  `            ``// Increment count of Left bracket` `            ``countLeft++; ` `            `  `            ``if` `(imbalance > 0) ` `            ``{` `                `  `                ``// swaps count is last swap count + total ` `                ``// number imbalanced brackets` `                ``swap += imbalance; ` `                `  `                ``// imbalance decremented by 1 as it solved` `                ``// only one imbalance of Left and Right` `                ``imbalance--;     ` `            ``}` `        ``} ` `        ``else` `if``(chars[i] == ``']'` `) ` `        ``{` `            `  `            ``// Increment count of Right bracket` `            ``countRight++; ` `            `  `            ``// imbalance is reset to current difference ` `            ``// between Left and Right brackets` `            ``imbalance = (countRight - countLeft); ` `        ``}` `    ``}` `    ``return` `swap;` `}`   `// Driver code  ` `int` `main()` `{` `    ``string s = ``"[]][]["``;` `    ``cout << swapCount(s) << endl;`   `    ``s = ``"[[][]]"``;` `    ``cout << swapCount(s) << endl;`   `    ``return` `0;` `}`   `// This code is contributed by divyeshrabadiya07`

## Java

 `// Java Program to count swaps required to balance string` `public` `class` `BalanceParan ` `{` `    `  `    ``static` `long` `swapCount(String s) ` `    ``{` `        ``char``[] chars = s.toCharArray();` `        `  `        ``// stores total number of Left and Right ` `        ``// brackets encountered` `        ``int` `countLeft = ``0``, countRight = ``0``; ` `                ``// swap stores the number of swaps required` `        ``//imbalance maintains the number of imbalance pair` `        ``int` `swap = ``0` `, imbalance = ``0``; ` `        `  `        ``for``(``int` `i =``0``; i< chars.length; i++) ` `        ``{` `            ``if``(chars[i] == ``'['``) ` `            ``{` `                ``// increment count of Left bracket` `                ``countLeft++; ` `                ``if``(imbalance > ``0``) ` `                ``{` `                    ``// swaps count is last swap count + total ` `                    ``// number imbalanced brackets` `                    ``swap += imbalance; ` `                    ``// imbalance decremented by 1 as it solved` `                    ``// only one imbalance of Left and Right` `                    ``imbalance--;     ` `                ``}` `            ``} ``else` `if``(chars[i] == ``']'` `) ` `            ``{` `                ``// increment count of Right bracket` `                ``countRight++; ` `                ``// imbalance is reset to current difference ` `                ``// between Left and Right brackets` `                ``imbalance = (countRight-countLeft); ` `            ``}` `        ``}` `        ``return` `swap;` `    ``}`   `// Driver code` `    ``public` `static` `void` `main(String args[]) ` `    ``{` `        ``String s = ``"[]][]["``;` `        ``System.out.println(swapCount(s) );`   `        ``s = ``"[[][]]"``;` `        ``System.out.println(swapCount(s) );` `        `  `    ``}` `}` `// This code is contributed by Janmejaya Das.`

## Python3

 `# Python3 program to count swaps required to` `# balance string ` `def` `swapCount(s): ` `    `  `    `  `    `  `    ``# Swap stores the number of swaps  ` `    ``# required imbalance maintains the` `    ``# number of imbalance pair ` `    ``swap ``=` `0` `    ``imbalance ``=` `0``; ` `    `  `    ``for` `i ``in` `s:` `        ``if` `i ``=``=` `'['``:` `            `  `            ``# Decrement the imbalance` `            ``imbalance ``-``=` `1` `        ``else``:` `            `  `            ``# Increment imbalance ` `            ``imbalance ``+``=` `1` `            `  `            ``if` `imbalance > ``0``:` `                ``swap ``+``=` `imbalance`   `    ``return` `swap`   `# Driver code ` `s ``=` `"[]][]["``; ` `print``(swapCount(s))`   `s ``=` `"[[][]]"``; ` `print``(swapCount(s))`   `# This code is contributed by Prateek Gupta and improved by Anvesh Govind Saxena`

## C#

 `// C# Program to count swaps required ` `// to balance string ` `using` `System;`   `class` `GFG` `{`   `public` `static` `long` `swapCount(``string` `s)` `{` `    ``char``[] chars = s.ToCharArray();`   `    ``// stores the total number of Left and ` `    ``// Right brackets encountered ` `    ``int` `countLeft = 0, countRight = 0;` `    `  `    ``// swap stores the number of swaps ` `    ``// required imbalance maintains the` `    ``// number of imbalance pair ` `    ``int` `swap = 0, imbalance = 0;`   `    ``for` `(``int` `i = 0; i < chars.Length; i++)` `    ``{` `        ``if` `(chars[i] == ``'['``)` `        ``{` `            ``// increment count of Left bracket ` `            ``countLeft++;` `            ``if` `(imbalance > 0)` `            ``{` `                ``// swaps count is last swap count + total ` `                ``// number imbalanced brackets ` `                ``swap += imbalance;` `                `  `                ``// imbalance decremented by 1 as it solved ` `                ``// only one imbalance of Left and Right ` `                ``imbalance--;` `            ``}` `        ``}` `        ``else` `if` `(chars[i] == ``']'``)` `        ``{` `            ``// increment count of Right bracket ` `            ``countRight++;` `            `  `            ``// imbalance is reset to current difference ` `            ``// between Left and Right brackets ` `            ``imbalance = (countRight - countLeft);` `        ``}` `    ``}` `    ``return` `swap;` `}`   `// Driver code ` `public` `static` `void` `Main(``string``[] args)` `{` `    ``string` `s = ``"[]][]["``;` `    ``Console.WriteLine(swapCount(s));`   `    ``s = ``"[[][]]"``;` `    ``Console.WriteLine(swapCount(s));` `}` `}`   `// This code is contributed by Shrikant13`

## Javascript

 ``

Output

```2
0```

Time Complexity :O(N)
Auxiliary Space : O(1)

This article is contributed by Aarti_Rathi and Aditya Kamath. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.