Related Articles

# Count removal of pairs required to be empty all Balanced Parenthesis subsequences

• Difficulty Level : Hard
• Last Updated : 07 May, 2021

Given a string str, the task is to find the maximum count of pairs (str[i], str[j]) of balanced parenthesis required to be removed such that the string does not contain any subsequence of balanced parenthesis:

Examples:

Input: str = “{(})”
Output:
Explanation:
Removing the pair of valid parenthesis(0, 2) modified str to “()”
Removing the pair of valid parenthesis(0, 1) modified str to “”.
Now, str does not contain any valid parenthesis. The required output is 2.

Input: str = “)}(}”
Output: 0

Approach: The problem can be solved using Greedy technique. Follow the steps below to solve the problem:

• Initialize three variables, say cntSqr, cntCurly and cntSml, to store the count of “[” valid parenthesis, count of “{}”valid parenthesis and count of small valid parenthesis respectively.
• Initialize a variable, say cntPairs, to store the count of pairs of balanced parenthesis required to be removed such that the string does not contain any subsequence of balanced parenthesis.
• Iterate over the characters of string and check for the following conditions:
• If str[i] == ‘(‘, then increment the value of cntSml by 1.
• If str[i] = ‘{‘, then increment the value of cntCurly by 1.
• If str[i] = ‘[‘, then increment the value of cntSqr by 1.
• If str[i] = ‘]’, then check if cntSqr greater than 0 or not. If found to be true, then decrement the value of cntSqr by 1 and increment the value of cntPairs by 1.
• If str[i] = ‘}’, then check if cntCurly greater than 0 or not. If found to be true, then decrement the value of cntCurly by 1 and increment the value of cntPairs by 1.
• If str[i] = ‘)’, then check if cntSml greater than 0 or not. If found to be true, then decrement the value of cntSml by 1 and increment the value of cntPairs by 1.
• Finally, print the value of cntPairs.

Below is the implementation for the above approach:

## C++

 `// C++ program to implement``// the above approach``#include ``using` `namespace` `std;` `// Function to find the maximum count of pairs``// required to be removed such that subsequence``// of string does not contain any valid parenthesis``void` `cntBalancedParenthesis(string s, ``int` `N)``{` `    ``// Stores count of pairs``    ``// of balanced parenthesis``    ``int` `cntPairs = 0;` `    ``// Stores count of curly``    ``// balanced parenthesis``    ``int` `cntCurly = 0;` `    ``// Stores count of small``    ``// balanced parenthesis``    ``int` `cntSml = 0;` `    ``// Stores count of square``    ``// balanced parenthesis``    ``int` `cntSqr = 0;` `    ``// Iterate over characters``    ``// of the string``    ``for` `(``int` `i = 0; i < N; i++) {``        ``if` `(s[i] == ``'{'``) {` `            ``// Update cntCurly``            ``cntCurly++;``        ``}` `        ``else` `if` `(s[i] == ``'('``) {` `            ``// Update cntSml``            ``cntSml++;``        ``}` `        ``else` `if` `(s[i] == ``'['``) {` `            ``// Update cntSqr``            ``cntSqr++;``        ``}` `        ``else` `if` `(s[i] == ``'}'` `&& cntCurly > 0) {` `            ``// Update cntCurly``            ``cntCurly--;` `            ``// Update cntPairs``            ``cntPairs++;``        ``}` `        ``else` `if` `(s[i] == ``')'` `&& cntSml > 0) {` `            ``// Update cntSml``            ``cntSml--;` `            ``// Update cntPairs``            ``cntPairs++;``        ``}` `        ``else` `if` `(s[i] == ``']'` `&& cntSqr > 0) {` `            ``// Update cntSml``            ``cntSqr--;` `            ``// Update cntPairs``            ``cntPairs++;``        ``}``    ``}` `    ``cout << cntPairs;``}` `// Driver Code``int` `main()``{``    ``// Given String``    ``string s = ``"{(})"``;``    ``int` `N = s.length();` `    ``// Function call``    ``cntBalancedParenthesis(s, N);` `    ``return` `0;``}`

## Java

 `// Java program to implement``// the above approach``import` `java.io.*;``class` `GFG``{` `  ``// Function to find the maximum count of pairs``  ``// required to be removed such that subsequence``  ``// of string does not contain any valid parenthesis``  ``static` `void` `cntBalancedParenthesis(String s, ``int` `N)``  ``{` `    ``// Stores count of pairs``    ``// of balanced parenthesis``    ``int` `cntPairs = ``0``;` `    ``// Stores count of curly``    ``// balanced parenthesis``    ``int` `cntCurly = ``0``;` `    ``// Stores count of small``    ``// balanced parenthesis``    ``int` `cntSml = ``0``;` `    ``// Stores count of square``    ``// balanced parenthesis``    ``int` `cntSqr = ``0``;` `    ``// Iterate over characters``    ``// of the string``    ``for` `(``int` `i = ``0``; i < N; i++) {``      ``if` `(s.charAt(i) == ``'{'``)``      ``{` `        ``// Update cntCurly``        ``cntCurly++;``      ``}` `      ``else` `if` `(s.charAt(i) == ``'('``)``      ``{` `        ``// Update cntSml``        ``cntSml++;``      ``}` `      ``else` `if` `(s.charAt(i) == ``'['``)``      ``{` `        ``// Update cntSqr``        ``cntSqr++;``      ``}` `      ``else` `if` `(s.charAt(i) == ``'}'` `&& cntCurly > ``0``)``      ``{` `        ``// Update cntCurly``        ``cntCurly--;` `        ``// Update cntPairs``        ``cntPairs++;``      ``}` `      ``else` `if` `(s.charAt(i) == ``')'` `&& cntSml > ``0``)``      ``{` `        ``// Update cntSml``        ``cntSml--;` `        ``// Update cntPairs``        ``cntPairs++;``      ``}` `      ``else` `if` `(s.charAt(i) == ``']'` `&& cntSqr > ``0``)``      ``{` `        ``// Update cntSml``        ``cntSqr--;` `        ``// Update cntPairs``        ``cntPairs++;``      ``}``    ``}``    ``System.out.println(cntPairs);``  ``}` `  ``// Driver Code``  ``public` `static` `void` `main(String[] args)``  ``{` `    ``// Given String``    ``String s = ``"{(})"``;``    ``int` `N = s.length();` `    ``// Function call``    ``cntBalancedParenthesis(s, N);``  ``}``}` `// This code is contributed by Dharanendra L V`

## Python3

 `# Python program to implement``# the above approach` `# Function to find the maximum count of pairs``# required to be removed such that subsequence``# of string does not contain any valid parenthesis``def` `cntBalancedParenthesis(s, N):``  ` `    ``# Stores count of pairs``    ``# of balanced parenthesis``    ``cntPairs ``=` `0``;` `    ``# Stores count of curly``    ``# balanced parenthesis``    ``cntCurly ``=` `0``;` `    ``# Stores count of small``    ``# balanced parenthesis``    ``cntSml ``=` `0``;` `    ``# Stores count of square``    ``# balanced parenthesis``    ``cntSqr ``=` `0``;` `    ``# Iterate over characters``    ``# of the string``    ``for` `i ``in` `range``(N):``        ``if` `(``ord``(s[i]) ``=``=` `ord``(``'{'``)):` `            ``# Update cntCurly``            ``cntCurly ``+``=` `1``;``        ``elif` `(``ord``(s[i]) ``=``=` `ord``(``'('``)):` `            ``# Update cntSml``            ``cntSml ``+``=` `1``;``        ``elif` `(``ord``(s[i]) ``=``=` `ord``(``'['``)):` `            ``# Update cntSqr``            ``cntSqr ``+``=` `1``;``        ``elif` `(``ord``(s[i]) ``=``=` `ord``(``'}'``) ``and` `cntCurly > ``0``):` `            ``# Update cntCurly``            ``cntCurly ``-``=``1``;` `            ``# Update cntPairs``            ``cntPairs ``+``=` `1``;``        ``elif` `(``ord``(s[i]) ``=``=` `ord``(``')'``) ``and` `cntSml > ``0``):` `            ``# Update cntSml``            ``cntSml ``-``=``1``;` `            ``# Update cntPairs``            ``cntPairs ``+``=` `1``;``        ``elif` `(``ord``(s[i]) ``=``=` `ord``(``']'``) ``and` `cntSqr > ``0``):` `            ``# Update cntSml``            ``cntSqr ``-``=``1``;` `            ``# Update cntPairs``            ``cntPairs ``+``=` `1``;``    ``print``(cntPairs);` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``  ` `    ``# Given String``    ``s ``=` `"{(})"``;``    ``N ``=` `len``(s);` `    ``# Function call``    ``cntBalancedParenthesis(s, N);` `# This code is contributed by 29AjayKumar`

## C#

 `// C# program to implement``// the above approach``using` `System;` `class` `GFG``{` `  ``// Function to find the maximum count of pairs``  ``// required to be removed such that subsequence``  ``// of string does not contain any valid parenthesis``  ``static` `void` `cntBalancedParenthesis(String s, ``int` `N)``  ``{` `    ``// Stores count of pairs``    ``// of balanced parenthesis``    ``int` `cntPairs = 0;` `    ``// Stores count of curly``    ``// balanced parenthesis``    ``int` `cntCurly = 0;` `    ``// Stores count of small``    ``// balanced parenthesis``    ``int` `cntSml = 0;` `    ``// Stores count of square``    ``// balanced parenthesis``    ``int` `cntSqr = 0;` `    ``// Iterate over characters``    ``// of the string``    ``for` `(``int` `i = 0; i < N; i++) {``      ``if` `(s[i] == ``'{'``) {` `        ``// Update cntCurly``        ``cntCurly++;``      ``}` `      ``else` `if` `(s[i] == ``'('``) {` `        ``// Update cntSml``        ``cntSml++;``      ``}` `      ``else` `if` `(s[i] == ``'['``) {` `        ``// Update cntSqr``        ``cntSqr++;``      ``}` `      ``else` `if` `(s[i] == ``'}'` `&& cntCurly > 0) {` `        ``// Update cntCurly``        ``cntCurly--;` `        ``// Update cntPairs``        ``cntPairs++;``      ``}` `      ``else` `if` `(s[i] == ``')'` `&& cntSml > 0) {` `        ``// Update cntSml``        ``cntSml--;` `        ``// Update cntPairs``        ``cntPairs++;``      ``}` `      ``else` `if` `(s[i] == ``']'` `&& cntSqr > 0) {` `        ``// Update cntSml``        ``cntSqr--;` `        ``// Update cntPairs``        ``cntPairs++;``      ``}``    ``}` `    ``Console.WriteLine(cntPairs);``  ``}` `  ``// Driver Code``  ``static` `public` `void` `Main()``  ``{` `    ``// Given String``    ``String s = ``"{(})"``;``    ``int` `N = s.Length;` `    ``// Function call``    ``cntBalancedParenthesis(s, N);``  ``}``}` `// This code is contributed by Dharanendra L V`

## Javascript

 ``
Output:
`2`

Time Complexity: O(N)
Auxiliary Space: O(1)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up