# Minimum Swaps for Bracket Balancing

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 for 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’ represents 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 0 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++

 `// 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;` `}`

## 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`

Output:

```2
0

```

Another Method:
Time Complexity = O(N)
Extra Space = O(1)
We can do without having to store the positions of ‘[‘.
Below is the implementation :

## 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): ` `    `  `    ``chars ``=` `s` `    `  `    ``# Stores total number of left and  ` `    ``# right brackets encountered ` `    ``countLeft ``=` `0` `    ``countRight ``=` `0` `    `  `    ``# Swap stores the number of swaps  ` `    ``# required imbalance maintains the` `    ``# number of imbalance pair ` `    ``swap ``=` `0` `    ``imbalance ``=` `0``; ` `    `  `    ``for` `i ``in` `range``(``len``(chars)):` `        ``if` `chars[i] ``=``=` `'['``:` `            `  `            ``# Increment count of left bracket` `            ``countLeft ``+``=` `1` `            `  `            ``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 ``-``=` `1` `                `  `        ``elif` `chars[i] ``=``=` `']'``:` `            `  `            ``# Increment count of right bracket ` `            ``countRight ``+``=` `1` `            `  `            ``# Imbalance is reset to current` `            ``# difference between left and ` `            ``# right brackets ` `            ``imbalance ``=` `(countRight ``-` `countLeft) `   `    ``return` `swap`   `# Driver code ` `s ``=` `"[]][]["``; ` `print``(swapCount(s))`   `s ``=` `"[[][]]"``; ` `print``(swapCount(s))`   `# This code is contributed by Prateek Gupta `

## 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`

Output:

```2
0

```

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up

Article Tags :
Practice Tags :

14

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.