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