Related Articles
Count pairs of parentheses sequences such that parentheses are balanced
• Difficulty Level : Hard
• Last Updated : 22 Sep, 2020

Given N bracket sequences, the task is to find the number of pairs of bracket sequences by joining which can be obtained a balanced bracket sequence as a whole. A bracket parentheses sequence can only be a part of a single pair.

Examples:

```Input: { ")())", ")", "((", "((", "(", ")", ")"}
Output:  2
Bracket sequence {1, 3} and {5, 6}

Input: {"()", "(())", "(())", "()"}
Output: 2
Since all brackets are balanced, hence we can form 2 pairs with 4.
```

Approach: The following steps can be followed to solve the above problem:

• Count required opening and closing brackets, of individuals.
• If required closing brackets > 0 and opening brackets is 0, then hash the bracket’s required closing number.
• Similarly, if required opening brackets > 0 and closing brackets is 0, then hash the bracket’s required opening number.
• Count the balanced bracket sequences.
• Add (number of balanced bracket sequences/2) to the number of pairs.
• For every number of sequences which requires same number of opening brackets, min(hash[open], hash[close]) will be added to the number of pairs

Below is the implementation of the above approach:

## C++

 `// C++ program to count the number of pairs` `// of balanced parentheses` `#include ` `using` `namespace` `std;`   `// Function to count the number of pairs` `int` `countPairs(string bracks[], ``int` `num)` `{`   `    ``// Hashing function to count the` `    ``// opening and closing brackets` `    ``unordered_map<``int``, ``int``> open, close;`   `    ``int` `cnt = 0;`   `    ``// Traverse for all bracket sequences` `    ``for` `(``int` `i = 0; i < num; i++) {`   `        ``// Get the string` `        ``string s = bracks[i];`   `        ``int` `l = s.length();`   `        ``// Counts the opening and closing required` `        ``int` `op = 0, cl = 0;`   `        ``// Traverse in the string` `        ``for` `(``int` `j = 0; j < l; j++) {`   `            ``// If it is a opening bracket` `            ``if` `(s[j] == ``'('``)` `                ``op++;` `            ``else` `// Closing bracket` `            ``{`   `                ``// If openings are there, then close it` `                ``if` `(op)` `                    ``op--;` `                ``else` `// Else increase count of closing` `                    ``cl++;` `            ``}` `        ``}`   `        ``// If requirements of openings` `        ``// are there and no closing` `        ``if` `(op && !cl)` `            ``open[op]++;`   `        ``// If requirements of closing` `        ``// are there and no opening` `        ``if` `(cl && !op)` `            ``close[cl]++;`   `        ``// Perfect` `        ``if` `(!op && !cl)` `            ``cnt++;` `    ``}`   `    ``// Divide by two since two` `    ``// perfect makes one pair` `    ``cnt = cnt / 2;`   `    ``// Traverse in the open and find` `    ``// corresponding minimum` `    ``for` `(``auto` `it : open)` `        ``cnt += min(it.second, close[it.first]);`   `    ``return` `cnt;` `}`   `// Driver Code` `int` `main()` `{` `    ``string bracks[] = { ``")())"``, ``")"``, ``"(("``, ``"(("``, ``"("``, ``")"``, ``")"` `};` `    ``int` `num = ``sizeof``(bracks) / ``sizeof``(bracks);`   `    ``cout << countPairs(bracks, num);` `}`

## Java

 `// Java program to count the number of pairs ` `// of balanced parentheses ` `import` `java.util.HashMap;`   `class` `GFG ` `{`   `// Function to count the number of pairs` `static` `int` `countPairs(String[] bracks, ``int` `num)` `{`   `    ``// Hashing function to count the` `    ``// opening and closing brackets` `    ``HashMap open = ``new` `HashMap<>();` `    ``HashMap close = ``new` `HashMap<>();`   `    ``int` `cnt = ``0``;`   `    ``// Traverse for all bracket sequences` `    ``for` `(``int` `i = ``0``; i < num; i++) ` `    ``{`   `        ``// Get the string` `        ``String s = bracks[i];` `        ``int` `l = s.length();`   `        ``// Counts the opening and closing required` `        ``int` `op = ``0``, cl = ``0``;`   `        ``// Traverse in the string` `        ``for` `(``int` `j = ``0``; j < l; j++) ` `        ``{`   `            ``// If it is a opening bracket` `            ``if` `(s.charAt(j) == ``'('``)` `                ``op++;`   `            ``// Closing bracket` `            ``else` `            ``{`   `                ``// If openings are there, then close it` `                ``if` `(op != ``0``)` `                    ``op--;`   `                ``// Else increase count of closing` `                ``else` `                    ``cl++;` `            ``}` `        ``}`   `        ``// If requirements of openings` `        ``// are there and no closing` `        ``if` `(op != ``0` `&& cl == ``0``)` `            ``open.put(op, open.get(op) == ``null` `? ` `                     ``1` `: open.get(op) + ``1``);`   `        ``// If requirements of closing` `        ``// are there and no opening` `        ``if` `(cl != ``0` `&& op == ``0``)` `            ``close.put(cl, close.get(cl) == ``null` `? ` `                      ``1` `: close.get(cl) + ``1``);`   `        ``// Perfect` `        ``if` `(op == ``0` `&& cl == ``0``)` `            ``cnt++;` `    ``}`   `    ``// Divide by two since two` `    ``// perfect makes one pair` `    ``cnt /= ``2``;`   `    ``// Traverse in the open and find` `    ``// corresponding minimum` `    ``for` `(HashMap.Entry it : open.entrySet())` `        ``cnt += Math.min(it.getValue(),` `              ``close.get(it.getKey()));`   `    ``return` `cnt;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args) ` `{` `    ``String[] bracks = { ``")())"``, ``")"``, ``"(("``, ` `                        ``"(("``, ``"("``, ``")"``, ``")"` `};` `    ``int` `num = bracks.length;`   `    ``System.out.println(countPairs(bracks, num));` `}` `}`   `// This code is contributed by` `// sanjeev2552`

## Python3

 `# Python3 program to count the number of pairs` `# of balanced parentheses` `import` `math as mt`   `# Function to count the number of pairs` `def` `countPairs(bracks, num):`   `    ``# Hashing function to count the` `    ``# opening and closing brackets` `    ``openn``=``dict``()` `    ``close``=``dict``()`   `    ``cnt ``=` `0`   `    ``# Traverse for all bracket sequences` `    ``for` `i ``in` `range``(num): `   `        ``# Get the string` `        ``s ``=` `bracks[i]`   `        ``l ``=` `len``(s)`   `        ``# Counts the opening and closing required` `        ``op,cl ``=` `0``,``0`   `        ``# Traverse in the string` `        ``for` `j ``in` `range``(l):` `            ``# If it is a opening bracket` `            ``if` `(s[j] ``=``=` `'('``):` `                ``op``+``=``1` `            ``else``: ``# Closing bracket` `            `    `                ``# If openings are there, then close it` `                ``if` `(op):` `                    ``op``-``=``1` `                ``else``: ``# Else increase count of closing` `                    ``cl``+``=``1` `            `  `        `    `        ``# If requirements of openings` `        ``# are there and no closing` `        ``if` `(op ``and` `cl``=``=``0``):` `            ``if` `op ``in` `openn.keys():` `                ``openn[op]``+``=``1` `            ``else``:` `                ``openn[op]``=``1` `                `    `        ``# If requirements of closing` `        ``# are there and no opening` `        ``if` `(cl ``and` `op``=``=``0``):` `            ``if` `cl ``in` `openn.keys():` `                ``close[cl]``+``=``1` `            ``else``:` `                ``close[cl]``=``1` `            `    `        ``# Perfect` `        ``if` `(op``=``=``0` `and` `cl``=``=``0``):` `            ``cnt``+``=``1` `    `    `    ``# Divide by two since two` `    ``# perfect makes one pair` `    ``cnt ``=` `cnt ``/``/``2`   `    ``# Traverse in the open and find` `    ``# corresponding minimum` `    ``for` `it ``in` `openn:` `        ``cnt ``+``=` `min``(openn[it], close[it])`   `    ``return` `cnt`     `# Driver Code` `bracks``=` `[``")())"``, ``")"``, ``"(("``, ``"(("``, ``"("``, ``")"``, ``")"` `]` `num ``=` `len``(bracks)`   `print``(countPairs(bracks, num))`   `#This code is contributed by Mohit kumar 29`

## C#

 `// C# program to count the number of pairs ` `// of balanced parentheses ` `using` `System;` `using` `System.Collections.Generic;` ` `  `class` `GFG{` ` `  `// Function to count the number of pairs` `static` `int` `countPairs(``string``[] bracks, ``int` `num)` `{` `  `  `    ``// Hashing function to count the` `    ``// opening and closing brackets` `    ``Dictionary<``int``,` `               ``int``> open = ``new` `Dictionary<``int``,` `                                          ``int``>();` `    ``Dictionary<``int``,` `               ``int``> close = ``new` `Dictionary<``int``,` `                                           ``int``>();` ` `  `    ``int` `cnt = 0;` ` `  `    ``// Traverse for all bracket sequences` `    ``for``(``int` `i = 0; i < num; i++) ` `    ``{` ` `  `        ``// Get the string` `        ``string` `s = bracks[i];` `        ``int` `l = s.Length;` ` `  `        ``// Counts the opening and closing required` `        ``int` `op = 0, cl = 0;` ` `  `        ``// Traverse in the string` `        ``for``(``int` `j = 0; j < l; j++) ` `        ``{` ` `  `            ``// If it is a opening bracket` `            ``if` `(s[j] == ``'('``)` `                ``op++;` ` `  `            ``// Closing bracket` `            ``else` `            ``{` ` `  `                ``// If openings are there, then close it` `                ``if` `(op != 0)` `                    ``op--;` ` `  `                ``// Else increase count of closing` `                ``else` `                    ``cl++;` `            ``}` `        ``}` ` `  `        ``// If requirements of openings` `        ``// are there and no closing` `        ``if` `(op != 0 && cl == 0)` `        ``{` `            ``if` `(open.ContainsKey(op))` `            ``{` `                ``open[op]++;` `            ``}` `            ``else` `            ``{` `                ``open[op] = 1;` `            ``}` `        ``}` ` `  `        ``// If requirements of closing` `        ``// are there and no opening` `        ``if` `(cl != 0 && op == 0)` `        ``{` `            ``if` `(close.ContainsKey(cl))` `            ``{` `                ``close[cl]++;` `            ``}` `            ``else` `            ``{` `                ``close[cl] = 1;` `            ``}` `        ``}` ` `  `        ``// Perfect` `        ``if` `(op == 0 && cl == 0)` `            ``cnt++;` `    ``}` ` `  `    ``// Divide by two since two` `    ``// perfect makes one pair` `    ``cnt /= 2;` ` `  `    ``// Traverse in the open and find` `    ``// corresponding minimum` `    ``foreach``(KeyValuePair<``int``, ``int``> it ``in` `open) ` `    ``{` `        ``cnt += Math.Min(it.Value, close[it.Value]);` `    ``}` `    ``return` `cnt;` `}` ` `  `// Driver Code` `public` `static` `void` `Main(``string``[] args) ` `{` `    ``string``[] bracks = { ``")())"``, ``")"``, ``"(("``, ` `                        ``"(("``, ``"("``, ``")"``, ``")"` `};` `  `  `    ``int` `num = bracks.Length;` ` `  `    ``Console.Write(countPairs(bracks, num));` `}` `}`   `// This code is contributed by rutvik_56`

Output:

```2

``` My Personal Notes arrow_drop_up
Recommended Articles
Page :