# Solution For Minimum Number Of Swaps To Make The String Balanced

Problem: Given a string with only characters ‘[’ and ‘]’, we have to find the minimum number of swaps required to make the string balanced. A string is considered balanced if it consists of alternating brackets, such as “[[]]” or “[][[]]”.

Approach:
To solve this problem we can use stack data structure. We need to traverse the string from left to right and for every opening bracket, we push its index onto the stack. If we encounter a closing bracket, we check if the stack is not empty and if the top of the stack is an opening bracket of the same type. If it is, we pop the opening bracket from the stack, and the current closing bracket is paired with it, otherwise, we push the index of the current closing bracket onto the stack. Once we have processed the whole string, the stack should only contain the indices of unmatched opening brackets.

Now, to make the given string balanced, we need to swap the unmatched opening brackets with unmatched closing brackets. We can calculate the number of unmatched opening and closing brackets using the stack size and return half of it as the minimum number of swaps required.

Code:

“`python
def min_swaps_to_balance(s: str) -> int:
stack = [] for i, c in enumerate(s):
if c == ‘[‘:
stack.append(i)
else:
if stack and s[stack[-1]] == ‘[‘:
stack.pop()
else:
stack.append(i)

``````return len(stack) // 2
``````

“`

Time Complexity: O(n) where n is the length of the given string.

Space Complexity: O(n) as we are using a stack to store the indices.

## Step by Step Implementation For Minimum Number Of Swaps To Make The String Balanced

```public int minSwaps(String s) {
int n = s.length();

// Count the number of zeroes and ones in the string
int count_0 = 0, count_1 = 0;
for (int i = 0; i < n; i++) {
if (s.charAt(i) == '0')
count_0++;
else
count_1++;
}

// If the number of zeroes and ones are equal, no swaps required
if (count_0 == count_1)
return 0;

// If the number of zeroes and ones are not equal, find the minimum number of swaps required
int min_swaps = Math.abs(count_0 - count_1);

// Traverse the string and count the number of consecutive ones and zeroes
int curr_count_0 = 0, curr_count_1 = 0;
for (int i = 0; i < n; i++) {
// If the current character is '0'
if (s.charAt(i) == '0') {
curr_count_0++;

// If the number of zeroes is more than the number of ones, update the minimum number of swaps
if (i + 1 < n && curr_count_0 > curr_count_1)
min_swaps = Math.min(min_swaps, curr_count_0 - curr_count_1);
}
// If the current character is '1'
else {
curr_count_1++;

// If the number of ones is more than the number of zeroes, update the minimum number of swaps
if (i + 1 < n && curr_count_1 > curr_count_0)
min_swaps = Math.min(min_swaps, curr_count_1 - curr_count_0);
}
}

return min_swaps;
}```
```def minimumSwaps(s):

# Create a list of tuples consisting of
# all the possible swaps that can be made

swaps = []
for i in range(len(s)):
for j in range(i+1, len(s)):
if s[i] == 'R' and s[j] == 'B':
swaps.append((i, j))
if s[i] == 'B' and s[j] == 'R':
swaps.append((i, j))

# Function to check if the string is balanced
# after making all the swaps

def isBalanced(s, swaps):

for swap in swaps:
i, j = swap

s[i], s[j] = s[j], s[i]

left = 0
right = 0

for k in range(len(s)):
if s[k] == 'R':
left += 1
else:
right += 1

if left != right:
s[i], s[j] = s[j], s[i]
return False

return True

# Function to find the minimum number of swaps
# required to make the string balanced

def minSwaps(s):
swaps = []
for i in range(len(s)):
for j in range(i+1, len(s)):
if s[i] == 'R' and s[j] == 'B':
swaps.append((i, j))
if s[i] == 'B' and s[j] == 'R':
swaps.append((i, j))

# Variable to keep track of the minimum number
# of swaps required
min_swaps = len(swaps)

# Find all the permutations of the swaps list
# and check if the string is balanced
# after making those swaps
for i in range(len(swaps)):
if isBalanced(s, swaps[:i] + swaps[i+1:]):
min_swaps = min(min_swaps, i)

return min_swaps

# Driver code
s = "BRBRR"
print(minSwaps(s))```
```function minimumNumberOfSwaps(s) {
}```
```int minimumNumberOfSwaps(string s)
{
// Create an array of pairs where first
// element is string and second element
// is position of first 'b' in the string
int n = s.length();
pair arr[n];
for (int i = 0; i < n; i++)
{
arr[i] = make_pair(s.substr(i), s.substr(i).find('b'));
}

// Sort the array by second element so that
// correct position of first 'b' is obtained
sort(arr, arr+n);

// To keep track of visited elements. Initialize
// all elements as not visited or false.
vector vis(n, false);

// Initialize result
int ans = 0;

// Traverse array
for (int i = 0; i < n; i++)
{
// already swapped and corrected or
// already present at correct pos
if (vis[i] || arr[i].second == i)
continue;

// find out the number of  node in
// this cycle and add in ans
int cycle_size = 0;
int j = i;
while (!vis[j])
{
vis[j] = 1;

// move to next node
j = arr[j].second;
cycle_size++;
}

if(cycle_size > 0)
{
ans += (cycle_size - 1);
}
}

// Return result
return ans;
}```
```public class Solution {
public int MinimumSwaps(string s) {