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 <bits/stdc++.h> 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[0]);
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<Integer, Integer> open = new HashMap<>();
HashMap<Integer, Integer> 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<Integer,
Integer> 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
<script> // Javascript program to count the number of pairs // of balanced parentheses // Function to count the number of pairs function countPairs( bracks,num)
{ // Hashing function to count the
// opening and closing brackets
let open = new Map();
let close = new Map();
let cnt = 0;
// Traverse for all bracket sequences
for (let i = 0; i < num; i++)
{
// Get the string
let s = bracks[i];
let l = s.length;
// Counts the opening and closing required
let op = 0, cl = 0;
// Traverse in the string
for (let 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)
open.set(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.set(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 (let [key, value] of open.entries())
cnt += Math.min(value,
close.get(value));
return cnt;
} // Driver Code let bracks=[ ")())" , ")" , "((" ,
"((" , "(" , ")" , ")" ];
let num = bracks.length; document.write(countPairs(bracks, num)); // This code is contributed by patel2127 </script> |
Output
2
Complexity Analysis:
- 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.