A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.

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 = 2

_Output: _1

Explanation:

Removal of the _**_0th character_, that is, _‘)’**, costs 1, generating a balanced string “()”. Therefore, the minimum cost is 1.

_ str = “)(“, A = 3, B = 9_Input:

_ 6_Output:

Explanation:

Removal of the _**_0th character**_ and appending at the end of the string generates a balanced string “()”._

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 ***by*, then reduce the count of ***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;`

`}`

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

A Computer Science portal for geeks. It contains well written, well thought and well explained computer science and programming articles, quizzes and practice/competitive programming/company interview Questions.