Count pairs of parentheses sequences such that parentheses are balanced

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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);
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


Output:

2


My Personal Notes arrow_drop_up

Recommended Posts: