## Related Articles

• Write an Interview Experience
• String Data Structure

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