Calculate the number of pairs that need to be removed so that all balanced bracket subsequences are empty

The C compiler treats strings as arrays of characters, so it is easy to remove characters from a string based on position. The first and last positions of the string must be checked for the presence of parentheses and must be removed. The string can be copied into another variable and displayed.

There are many predefined functions in C that can be used efficiently to manipulate strings. In C language, deleting a character from the starting or ending position is easy with the help of functions.

Remove opening and closing brackets from string

Brackets are single characters that are part of the input string and can be removed from the string following the logic and algorithm given below

character is any alphanumeric key we see on the keyboard and it is stored in a character variable in C.

() are called brackets in c. We need to identify this character in the string entered by the user and remove it from the string.

An array is a variable that has many storage locations addressed by a single name and consecutive numbers, while a string is an array of characters.

There are many situations where we need to remove brackets from strings, such as when solving regular expressions.

grammar

The function countRemoval accepts the string str as input and returns an integer value representing the number of removal pairs required to make all balanced bracket subsequences in the string empty. The function uses the variable count to keep track of the number of deletions required, initially set to 0. It also uses the variable Balance to track the balance between the number of opening and closing brackets in the string. The function then iterates over the length of the string and checks the character at each index. If the character is a left bracket, the balance is increased by 1, and if it is a right bracket, the balance is decremented by 1. If the balance becomes negative, it means there is an extra right bracket, the number of removals is plus 1, and the balance is reset to 0. After the loop, the count is updated to include the remaining balance divided by 2 as the amount of deletion required to make all balancing bracket subsequences in the string empty.

int countRemoval(string str) {
   int count = 0;
   int balance = 0;
   for (int i = 0; i < str.length(); i++) {
      if (str[i] == '(') {
         balance++;
      } else {
         balance--;
      }
      if (balance < 0) {
         count++;
         balance = 0;
      }
   }
   count += balance / 2;
   return count;
} 

algorithm

• Step 1 - Declare str1, str2, initialized to null.

• Step 2 - Declare integer variables len,n,i

• Step 3 - Accept str1 from console

• Step 4 - Check if the first character is (

• Step 5 - If n = 1

• Step 6 - When n

• Step 7 - Check if the last character of str2 is ).

• Step 8 - If yes, replace it with \0.

• Step 9 - Print str2 containing the input string minus sign ().

method

Method 1 - Brute force recursion: In the first method, we use brute force recursion to find all possible subsequences and check if they are balanced. If the subsequence is balanced, we remove a pair of brackets and count the number of deleted bracket pairs. We calculate the minimum number of pair deletions required to empty the string.

Method 2 - Dynamic Programming: The second method uses dynamic programming to optimize the solution. We can use a 2D DP table to store the minimum number of deletions required for a substring from index "i" to "j". We iterate over the string and populate the DP table based on the given criteria.

Method 1 Violent Recursion

Code

In this code, we check all possible subsequence combinations, which results in exponential time complexity. For larger inputs, this method may not be efficient.

#include <iostream>
#include <string>
using namespace std;

int countRemovalsRecursion(const string &s, int index, int open) {
   if (index == s.size()) {
      return open;
   }

   if (s[index] == '(') {
      return countRemovalsRecursion(s, index + 1, open + 1);
   } else if (open > 0) {
      return countRemovalsRecursion(s, index + 1, open - 1);
   } else {
      return 1 + countRemovalsRecursion(s, index + 1, open);
   }
}

int main() {
   string s = "(()())(";
   cout << "Input string: " << s << endl;
   cout << "Minimum removals (Brute Force Recursion): " << countRemovalsRecursion(s, 0, 0) << endl;
   return 0;
}

Output

Input string: (()())(
Minimum removals (Brute Force Recursion): 1

Method 2

Example

This dynamic programming solution calculates the minimum number of deletions required to empty all balanced bracket subsequences. It iterates over the string, updates a one-dimensional DP table with the number of left brackets, and returns the final DP value as the minimum amount to remove.

#include <iostream>
#include <string>
#include <vector>
using namespace std;

int countRemovalsDP(const string &s) {
   int n = s.size();
   vector<int> dp(n + 1, 0);

   for (int i = 0; i < n; ++i) {
      if (s[i] == '(') {
         dp[i + 1] = dp[i] + 1;
      } else {
         dp[i + 1] = max(dp[i] - 1, 0);
      }
   }
   return dp[n];
}

int main() {
   string s = "(()())()";
   cout << "Input string: " << s << endl;
   cout << "Minimum removals (Dynamic Programming): " << countRemovalsDP(s) << endl;
   return 0;
}

Output

Input string: (()())()
Minimum removals (Dynamic Programming): 0

in conclusion

Basic concepts of C language, such as what is the difference between character and string data types, string delimiters, how to initialize strings and arrays, calculation of the position where the first character of the array is index 0 and the last character used in this program One character must be empty to get correct output.

The removal of parentheses in a program is achieved by implementing basic, simple concepts of C programming.

The above is the detailed content of Calculate the number of pairs that need to be removed so that all balanced bracket subsequences are empty. For more information, please follow other related articles on the PHP Chinese website!