Given a string **str** of length **N**, repesenting a bracket sequence, and two integers **A** and **B**, the task is to find the minimum cost required to obtain a regular bracket sequence from **str** by performing any number of moves(*possibly zero*) of the following types:

- Remove a character from the string for a cost
**A**. - Remove a character from the string and append at the end of the string for a cost
**B**.

A balanced bracket sequence can be of the following types:

- Empty string
- A string consisting of a closing bracket corresponding to every opening bracket.

**Examples:**

Input:str = “)()”, A = 1, B = 2Output:1Explanation:

Removal of the0, that is,^{th}character‘)’, costs 1, generating a balanced string “()”. Therefore, the minimum cost is 1.Input:str = “)(“, A = 3, B = 9Output:6Explanation:

Removal of the0and appending at the end of the string generates a balanced string “()”.^{th}character

Therefore, cost = 9.

Removal of both the characters generates an empty string for a cost 6.

Therefore, the minimum cost to generate a balanced string is 6.

**Approach: **Follow the steps below to solve the problem:

- Count the frequencies of opening
**‘(‘**and closing**‘)’**brackets in the given string and store the one more frequent of the two. - Minimum cost will be at least
**a * (abs(open – count))**, as these brackets need to be removed in order to balance the string. - Count the number of unbalanced open and closing brackets in the string. If the open brackets are
**excess**, then reduce the count ofby**unbalanced open brackets**. Similarly, reduce count of**count of excess open brackets**if closing brackets are excess.**unbalanced closing brackets** - Now, calculate the
**cost of removing all unbalanced open and unbalanced closed brackets**as well as the**cost of removing unbalanced closed brackets and adding them to the end**. Compare and add the minimum of the two costs to the answer. - Therefore, the minimum cost required to generate a balanced bracket sequence is given by the following equation:

Minimum Cost to generate a balanced string =

a * (abs(open – close)) + min( a*(unbalanced open + unbalanced closed), b*(unbalanced closed parenthesis))

Below is the implementation of the above approach:

## C++

`// C++ Program to implement` `// the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to calculate the minimum cost` `// required to generate a balanced bracket` `// sequence` `void` `minCost(string str, ` `int` `a, ` `int` `b)` `{` ` ` `// Stores the count of` ` ` `// unbalanced open brackets` ` ` `int` `openUnbalanced = 0;` ` ` `// Stores the count of` ` ` `// unbalanced closed brackets` ` ` `int` `closedUnbalanced = 0;` ` ` `// Stores the count of` ` ` `// open brackets` ` ` `int` `openCount = 0;` ` ` `// Stores the count of` ` ` `// closed brackets` ` ` `int` `closedCount = 0;` ` ` `for` `(` `int` `i = 0; str[i] != ` `'\0'` `; i++) {` ` ` `// If open brace is encountered` ` ` `if` `(str[i] == ` `'('` `) {` ` ` `openUnbalanced++;` ` ` `openCount++;` ` ` `}` ` ` `// Otherwise` ` ` `else` `{` ` ` `// If no unbalanced open` ` ` `// brackets are present` ` ` `if` `(openUnbalanced == 0)` ` ` `// Increase count of` ` ` `// unbalanced closed brackets` ` ` `closedUnbalanced++;` ` ` `// Otherwise` ` ` `else` ` ` `// Reduce count of` ` ` `// unbalanced open brackets` ` ` `openUnbalanced--;` ` ` `// Increase count of` ` ` `// closed brackets` ` ` `closedCount++;` ` ` `}` ` ` `}` ` ` `// Calculate lower bound of minimum cost` ` ` `int` `result = a * (` `abs` `(openCount` ` ` `- closedCount));` ` ` `// Reduce excess open or closed brackets` ` ` `// to prevent counting them twice` ` ` `if` `(closedCount > openCount)` ` ` `closedUnbalanced` ` ` `-= (closedCount - openCount);` ` ` `if` `(openCount > closedCount)` ` ` `openUnbalanced` ` ` `-= (openCount - closedCount);` ` ` `// Update answer by adding minimum of` ` ` `// removing both unbalanced open and` ` ` `// closed brackets or inserting closed` ` ` `// unbalanced brackets to end of string` ` ` `result += min(a * (openUnbalanced` ` ` `+ closedUnbalanced),` ` ` `b * closedUnbalanced);` ` ` `// Print the result` ` ` `cout << result << endl;` `}` `// Driver Code` `int` `main()` `{` ` ` `string str = ` `"))()(()()("` `;` ` ` `int` `A = 1, B = 3;` ` ` `minCost(str, A, B);` ` ` `return` `0;` `}` |

*chevron_right*

*filter_none*

## Java

`// Java program to implement` `// the above approach` `import` `java.util.*;` `class` `GFG{` `// Function to calculate the minimum cost` `// required to generate a balanced bracket` `// sequence` `static` `void` `minCost(String str, ` `int` `a, ` `int` `b)` `{` ` ` ` ` `// Stores the count of` ` ` `// unbalanced open brackets` ` ` `int` `openUnbalanced = ` `0` `;` ` ` `// Stores the count of` ` ` `// unbalanced closed brackets` ` ` `int` `closedUnbalanced = ` `0` `;` ` ` `// Stores the count of` ` ` `// open brackets` ` ` `int` `openCount = ` `0` `;` ` ` `// Stores the count of` ` ` `// closed brackets` ` ` `int` `closedCount = ` `0` `;` ` ` `for` `(` `int` `i = ` `0` `; i < str.length(); i++)` ` ` `{` ` ` `// If open brace is encountered` ` ` `if` `(str.charAt(i) == ` `'('` `)` ` ` `{` ` ` `openUnbalanced++;` ` ` `openCount++;` ` ` `}` ` ` `// Otherwise` ` ` `else` ` ` `{` ` ` ` ` `// If no unbalanced open` ` ` `// brackets are present` ` ` `if` `(openUnbalanced == ` `0` `)` ` ` `// Increase count of` ` ` `// unbalanced closed brackets` ` ` `closedUnbalanced++;` ` ` `// Otherwise` ` ` `else` ` ` `// Reduce count of` ` ` `// unbalanced open brackets` ` ` `openUnbalanced--;` ` ` `// Increase count of` ` ` `// closed brackets` ` ` `closedCount++;` ` ` `}` ` ` `}` ` ` `// Calculate lower bound of minimum cost` ` ` `int` `result = a * (Math.abs(openCount - ` ` ` `closedCount));` ` ` `// Reduce excess open or closed brackets` ` ` `// to prevent counting them twice` ` ` `if` `(closedCount > openCount)` ` ` `closedUnbalanced -= (closedCount - ` ` ` `openCount);` ` ` `if` `(openCount > closedCount)` ` ` `openUnbalanced -= (openCount - ` ` ` `closedCount);` ` ` `// Update answer by adding minimum of` ` ` `// removing both unbalanced open and` ` ` `// closed brackets or inserting closed` ` ` `// unbalanced brackets to end of String` ` ` `result += Math.min(a * (openUnbalanced + ` ` ` `closedUnbalanced),` ` ` `b * closedUnbalanced);` ` ` `// Print the result` ` ` `System.out.print(result + ` `"\n"` `);` `}` `// Driver Code` `public` `static` `void` `main(String[] args)` `{` ` ` `String str = ` `"))()(()()("` `;` ` ` `int` `A = ` `1` `, B = ` `3` `;` ` ` ` ` `minCost(str, A, B);` `}` `}` `// This code is contributed by amal kumar choubey` |

*chevron_right*

*filter_none*

## Python3

`# Python3 program to implement` `# the above approach` `# Function to calculate the minimum cost` `# required to generate a balanced bracket` `# sequence` `def` `minCost(` `str` `, a, b):` ` ` `# Stores the count of` ` ` `# unbalanced open brackets` ` ` `openUnbalanced ` `=` `0` `;` ` ` `# Stores the count of` ` ` `# unbalanced closed brackets` ` ` `closedUnbalanced ` `=` `0` `;` ` ` `# Stores the count of` ` ` `# open brackets` ` ` `openCount ` `=` `0` `;` ` ` `# Stores the count of` ` ` `# closed brackets` ` ` `closedCount ` `=` `0` `;` ` ` `for` `i ` `in` `range` `(` `len` `(` `str` `)):` ` ` `# If open brace is encountered` ` ` `if` `(` `str` `[i] ` `=` `=` `'('` `):` ` ` `openUnbalanced ` `+` `=` `1` `;` ` ` `openCount ` `+` `=` `1` `;` ` ` ` ` `# Otherwise` ` ` `else` `:` ` ` `# If no unbalanced open` ` ` `# brackets are present` ` ` `if` `(openUnbalanced ` `=` `=` `0` `):` ` ` `# Increase count of` ` ` `# unbalanced closed brackets` ` ` `closedUnbalanced ` `+` `=` `1` `;` ` ` `# Otherwise` ` ` `else` `:` ` ` `# Reduce count of` ` ` `# unbalanced open brackets` ` ` `openUnbalanced ` `-` `=` `1` `;` ` ` `# Increase count of` ` ` `# closed brackets` ` ` `closedCount ` `+` `=` `1` `;` ` ` ` ` `# Calculate lower bound of minimum cost` ` ` `result ` `=` `a ` `*` `(` `abs` `(openCount ` `-` `closedCount));` ` ` `# Reduce excess open or closed brackets` ` ` `# to prevent counting them twice` ` ` `if` `(closedCount > openCount):` ` ` `closedUnbalanced ` `-` `=` `(closedCount ` `-` `openCount);` ` ` `if` `(openCount > closedCount):` ` ` `openUnbalanced ` `-` `=` `(openCount ` `-` `closedCount);` ` ` `# Update answer by adding minimum of` ` ` `# removing both unbalanced open and` ` ` `# closed brackets or inserting closed` ` ` `# unbalanced brackets to end of String` ` ` `result ` `+` `=` `min` `(a ` `*` `(openUnbalanced ` `+` ` ` `closedUnbalanced), ` ` ` `b ` `*` `closedUnbalanced);` ` ` `# Prthe result` ` ` `print` `(result);` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` `str` `=` `"))()(()()("` `;` ` ` `A ` `=` `1` `; B ` `=` `3` `;` ` ` `minCost(` `str` `, A, B);` `# This code is contributed by Rohit_ranjan` |

*chevron_right*

*filter_none*

## C#

`// C# program to implement` `// the above approach` `using` `System;` `class` `GFG{` `// Function to calculate the minimum cost` `// required to generate a balanced bracket` `// sequence` `static` `void` `minCost(String str, ` `int` `a, ` `int` `b)` `{` ` ` ` ` `// Stores the count of` ` ` `// unbalanced open brackets` ` ` `int` `openUnbalanced = 0;` ` ` `// Stores the count of` ` ` `// unbalanced closed brackets` ` ` `int` `closedUnbalanced = 0;` ` ` `// Stores the count of` ` ` `// open brackets` ` ` `int` `openCount = 0;` ` ` `// Stores the count of` ` ` `// closed brackets` ` ` `int` `closedCount = 0;` ` ` `for` `(` `int` `i = 0; i < str.Length; i++)` ` ` `{` ` ` `// If open brace is encountered` ` ` `if` `(str[i] == ` `'('` `)` ` ` `{` ` ` `openUnbalanced++;` ` ` `openCount++;` ` ` `}` ` ` `// Otherwise` ` ` `else` ` ` `{` ` ` ` ` `// If no unbalanced open` ` ` `// brackets are present` ` ` `if` `(openUnbalanced == 0)` ` ` `// Increase count of` ` ` `// unbalanced closed brackets` ` ` `closedUnbalanced++;` ` ` `// Otherwise` ` ` `else` ` ` `// Reduce count of` ` ` `// unbalanced open brackets` ` ` `openUnbalanced--;` ` ` `// Increase count of` ` ` `// closed brackets` ` ` `closedCount++;` ` ` `}` ` ` `}` ` ` `// Calculate lower bound of minimum cost` ` ` `int` `result = a * (Math.Abs(openCount - ` ` ` `closedCount));` ` ` `// Reduce excess open or closed brackets` ` ` `// to prevent counting them twice` ` ` `if` `(closedCount > openCount)` ` ` `closedUnbalanced -= (closedCount - ` ` ` `openCount);` ` ` `if` `(openCount > closedCount)` ` ` `openUnbalanced -= (openCount - ` ` ` `closedCount);` ` ` `// Update answer by adding minimum of` ` ` `// removing both unbalanced open and` ` ` `// closed brackets or inserting closed` ` ` `// unbalanced brackets to end of String` ` ` `result += Math.Min(a * (openUnbalanced + ` ` ` `closedUnbalanced),` ` ` `b * closedUnbalanced);` ` ` `// Print the result` ` ` `Console.Write(result + ` `"\n"` `);` `}` `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` ` ` `String str = ` `"))()(()()("` `;` ` ` `int` `A = 1, B = 3;` ` ` ` ` `minCost(str, A, B);` `}` `}` `// This code is contributed by gauravrajput1` |

*chevron_right*

*filter_none*

**Output:**

4

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

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.

## Recommended Posts:

- Check if the bracket sequence can be balanced with at most one change in the position of a bracket
- Check if the bracket sequence can be balanced with at most one change in the position of a bracket | Set 2
- Convert an unbalanced bracket sequence to a balanced sequence
- Find the lexicographical next balanced bracket sequence
- Find index of closing bracket for a given opening bracket in an expression
- Minimum number of bracket reversals needed to make an expression balanced
- Minimum number of bracket reversals needed to make an expression balanced | Set - 2
- Minimum operation required to make a balanced sequence
- Print the balanced bracket expression using given brackets
- Number of balanced bracket subsequence of length 2 and 4
- Number of closing brackets needed to complete a regular bracket sequence
- Minimum cost to empty Array where cost of removing an element is 2^(removed_count) * arr[i]
- Minimum Swaps for Bracket Balancing
- Generate minimum sum sequence of integers with even elements greater
- Minimum flips required to generate continuous substrings of 0’s and 1’s
- Minimum cost required to convert all Subarrays of size K to a single element
- Minimum cost required to connect all houses in a city
- Minimum cost of flipping characters required to convert Binary String to 0s only
- Minimum cost required to move all elements to the same position
- Minimum steps required to rearrange given array to a power sequence of 2

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

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.