# Count pairs of parentheses sequences such that parentheses are balanced

• Difficulty Level : Hard
• Last Updated : 16 Jun, 2022

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 are 0, then hash the bracket’s required closing number.
• Similarly, if required opening brackets > 0 and closing brackets are 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 that 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`

## Javascript

 ``

Output:

`2`

Time Complexity: O(N*M), as we are using nested loops to traverse N*M times.Where N is the number of strings in the bracks and M is the maximum length of the strings present in the bracks.

Auxiliary Space: O(N), as we are using extra space for the map. Where N is the number of strings in the bracks.

My Personal Notes arrow_drop_up