# Minimize length by removing subsequences forming valid parenthesis from a given string

• Difficulty Level : Hard
• Last Updated : 28 May, 2022

Given a string S consisting of ‘(‘, ‘)’, ‘[‘ and ‘]’, the task is to find the minimum count of remaining characters in the string by removing subsequences of the valid parenthesis.

Examples:

Input: S = “[]])([”
Output:
Explanation:
Removing the subsequence { str[0], str[1] } modifies S to “])([“.
Therefore, the required output is 4.

Input: S = “([)(])”
Output:
Explanation:
Removing the subsequence { str[0], str[2] } modifies S to “[(])”.
Removing the subsequence { str[0], str[2] } modifies S to “()”.
Removing the subsequence { str[0], str[1] } modifies S to “”.
Therefore, the required output is 0.

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

• The idea is to handle the round parenthesis, ‘()’ and the bracket parenthesis, ‘[]’ in two separate stacks.
• Initialize two variables say, roundCount and squareCount to store the count of opening parenthesis in valid parenthesis of ‘()’ and ‘[]’ respectively.
• Iterate over each character of the given string and calculate the length of valid parenthesis of ‘()’ and ‘[]’ using two different stacks.
• Finally, print the value of (N – 2 * (roundCount + squareCount)).

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the minimum count of remaining``// characters left into the string by removing``// the valid subsequences``void` `deleteSubseq(string s)``{` `    ``// Length of the string``    ``int` `N = s.size();` `    ``// Stores opening parenthesis``    ``// '(' of the given string``    ``stack<``char``> roundStk;` `    ``// Stores square parenthesis``    ``// '[' of the given string``    ``stack<``char``> squareStk;` `    ``// Stores count of opening parenthesis '('``    ``// in valid subsequences``    ``int` `roundCount = 0;` `    ``// Stores count of opening parenthesis '['``    ``// in valid subsequences``    ``int` `squareCount = 0;` `    ``// Iterate over each``    ``// characters of S``    ``for` `(``int` `i = 0; i < N; i++)``    ``{` `        ``// If current character is '['``        ``if` `(s[i] == ``'['``)``        ``{` `            ``// insert into stack``            ``squareStk.push(s[i]);``        ``}` `        ``// If i is equal to ']'``        ``else` `if` `(s[i] == ``']'``)``        ``{` `            ``// If stack is not empty and``            ``// top element of stack is '['``            ``if` `(squareStk.size() != 0``                ``&& squareStk.top() == ``'['``)``            ``{` `                ``// Remove top element from stack``                ``squareStk.pop();` `                ``// Update squareCount``                ``squareCount += 1;``            ``}``        ``}` `        ``// If current character is '('``        ``else` `if` `(s[i] == ``'('``)``        ``{` `            ``// Insert into stack``            ``roundStk.push(s[i]);``        ``}` `        ``// If i is equal to ')'``        ``else``        ``{` `            ``// If stack is not empty and``            ``// top element of stack is '('``            ``if` `(roundStk.size() != 0``                ``&& squareStk.top() == ``'('``)``            ``{` `                ``// Remove top element from stack``                ``squareStk.pop();` `                ``// Update roundCount``                ``roundCount += 1;``            ``}``        ``}``    ``}` `    ``// Print the minimum number of remaining``    ``// characters left into S``    ``cout << (N - (2 * squareCount + 2 * roundCount));``}` `// Driver code``int` `main()``{` `    ``// input string``    ``string s = ``"[]])(["``;` `    ``// function call``    ``deleteSubseq(s);``}` `// This code is contributed by gauravrajput1`

## Java

 `/*package whatever //do not write package name here */` `// Java program for the above approach``import` `java.io.*;``import` `java.util.Stack;``class` `GFG``{` `  ``// Function to find the minimum count of remaining``  ``// characters left into the string by removing``  ``// the valid subsequences``  ``public` `static` `void` `deleteSubseq(String s)``  ``{` `    ``// Length of the string``    ``int` `N = s.length();` `    ``// Stores opening parenthesis``    ``// '(' of the given string``    ``Stack roundStk = ``new` `Stack<>();` `    ``// Stores square parenthesis``    ``// '[' of the given string``    ``Stack squareStk = ``new` `Stack<>();` `    ``// Stores count of opening parenthesis '('``    ``// in valid subsequences``    ``int` `roundCount = ``0``;` `    ``// Stores count of opening parenthesis '['``    ``// in valid subsequences``    ``int` `squareCount = ``0``;` `    ``// Iterate over each``    ``// characters of S``    ``for` `(``int` `i = ``0``; i < N; i++)``    ``{` `      ``// If current character is '['``      ``if` `(s.charAt(i) == ``'['``)``      ``{` `        ``// insert into stack``        ``squareStk.push(s.charAt(i));``      ``}` `      ``// If i is equal to ']'``      ``else` `if` `(s.charAt(i) == ``']'``)``      ``{` `        ``// If stack is not empty and``        ``// top element of stack is '['``        ``if` `(squareStk.size() != ``0``            ``&& squareStk.peek() == ``'['``)``        ``{` `          ``// Remove top element from stack``          ``squareStk.pop();` `          ``// Update squareCount``          ``squareCount += ``1``;``        ``}``      ``}` `      ``// If current character is '('``      ``else` `if` `(s.charAt(i) == ``'('``)``      ``{` `        ``// Insert into stack``        ``roundStk.push(s.charAt(i));``      ``}` `      ``// If i is equal to ')'``      ``else``      ``{` `        ``// If stack is not empty and``        ``// top element of stack is '('``        ``if` `(roundStk.size() != ``0``            ``&& squareStk.peek() == ``'('``)``        ``{` `          ``// Remove top element from stack``          ``squareStk.pop();` `          ``// Update roundCount``          ``roundCount += ``1``;``        ``}``      ``}``    ``}` `    ``// Print the minimum number of remaining``    ``// characters left into S``    ``System.out.println(``      ``N - (``2` `* squareCount + ``2` `* roundCount));``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{` `    ``// input string``    ``String s = ``"[]])(["``;` `    ``// function call``    ``deleteSubseq(s);``  ``}``}` `// This code is contributed by aditya7409`

## Python3

 `# Python program for the above approach` `# Function to find the minimum count of remaining``# characters left into the string by removing``# the valid subsequences``def` `deleteSubseq(S):` `    ``# Length of the string``    ``N ``=` `len``(S)` `    ``# Stores opening parenthesis``    ``# '(' of the given string``    ``roundStk ``=` `[]` `    ``# Stores square parenthesis``    ``# '[' of the given string``    ``squareStk ``=` `[]` `    ``# Stores count of opening parenthesis '('``    ``# in valid subsequences``    ``roundCount ``=` `0` `    ``# Stores count of opening parenthesis '['``    ``# in valid subsequences``    ``squareCount ``=` `0` `    ``# Iterate over each``    ``# characters of S``    ``for` `i ``in` `S:` `        ``# If current character is '['``        ``if` `i ``=``=` `'['``:` `            ``# Insert into stack``            ``squareStk.append(i)` `        ``# If i is equal to ']'``        ``elif` `i ``=``=` `']'``:``            ` `            ` `            ``# If stack is not empty and``            ``# top element of stack is '['``            ``if` `squareStk ``and` `squareStk[``-``1``] ``=``=` `'['``:``                ` `                ` `                ``# Remove top element from stack``                ``squareStk.pop()``                ` `                ` `                ``# Update squareCount``                ``squareCount ``+``=` `1` `        ``# If current character is '('``        ``elif` `i ``=``=` `'('``:``            ` `            ` `            ``# Insert into stack``            ``roundStk.append(i)``        ``else``:``            ` `            ` `            ``# If stack is not empty and``            ``# top element of stack is '('``            ``if` `roundStk ``and` `roundStk[``-``1``] ``=``=` `'('``:``                ` `                ` `                ``# Remove top element from stack``                ``roundStk.pop()``                ` `                ` `                ``# Update roundCount``                ``roundCount ``+``=` `1`  `    ``# Print the minimum number of remaining``    ``# characters left into S``    ``print``(N ``-` `(``2` `*` `squareCount ``+` `2` `*` `roundCount))`  `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Given string``    ``S ``=` `'[]])(['` `    ``# Function Call``    ``deleteSubseq(S)`

## C#

 `/*package whatever //do not write package name here */` `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;``class` `GFG``{` `  ``// Function to find the minimum count of remaining``  ``// characters left into the string by removing``  ``// the valid subsequences``  ``public` `static` `void` `deleteSubseq(String s)``  ``{` `    ``// Length of the string``    ``int` `N = s.Length;` `    ``// Stores opening parenthesis``    ``// '(' of the given string``    ``Stack<``char``> roundStk = ``new` `Stack<``char``>();` `    ``// Stores square parenthesis``    ``// '[' of the given string``    ``Stack<``char``> squareStk = ``new` `Stack<``char``>();` `    ``// Stores count of opening parenthesis '('``    ``// in valid subsequences``    ``int` `roundCount = 0;` `    ``// Stores count of opening parenthesis '['``    ``// in valid subsequences``    ``int` `squareCount = 0;` `    ``// Iterate over each``    ``// characters of S``    ``for` `(``int` `i = 0; i < N; i++)``    ``{` `      ``// If current character is '['``      ``if` `(s[i] == ``'['``)``      ``{` `        ``// insert into stack``        ``squareStk.Push(s[i]);``      ``}` `      ``// If i is equal to ']'``      ``else` `if` `(s[i] == ``']'``)``      ``{` `        ``// If stack is not empty and``        ``// top element of stack is '['``        ``if` `(squareStk.Count != 0``            ``&& squareStk.Peek() == ``'['``)``        ``{` `          ``// Remove top element from stack``          ``squareStk.Pop();` `          ``// Update squareCount``          ``squareCount += 1;``        ``}``      ``}` `      ``// If current character is '('``      ``else` `if` `(s[i] == ``'('``)``      ``{` `        ``// Insert into stack``        ``roundStk.Push(s[i]);``      ``}` `      ``// If i is equal to ')'``      ``else``      ``{` `        ``// If stack is not empty and``        ``// top element of stack is '('``        ``if` `(roundStk.Count != 0``            ``&& squareStk.Peek() == ``'('``)``        ``{` `          ``// Remove top element from stack``          ``squareStk.Pop();` `          ``// Update roundCount``          ``roundCount += 1;``        ``}``      ``}``    ``}` `    ``// Print the minimum number of remaining``    ``// characters left into S``    ``Console.WriteLine(``      ``N - (2 * squareCount + 2 * roundCount));``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main(String[] args)``  ``{` `    ``// input string``    ``String s = ``"[]])(["``;` `    ``// function call``    ``deleteSubseq(s);``  ``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

`4`

Time Complexity: O(N) where n is number of elements in given string. As, we are using a loop to traverse N times so it will cost us O(N) time.
Auxiliary Space: O(N), as we are using extra space for stack.

My Personal Notes arrow_drop_up