平衡括号子串的数量

给定一个由’ ( ‘和’ ) ‘组成的平衡括号字符串。任务是找到给定字符串中平衡括号子字符串

例子 ：

Input : str = “()()()”
Output : 6
(), (), (), ()(), ()(), ()()()

Input : str = “(())()”
Output : 4
(), (()), (), (())()

方法 ：
让我们假设，每当遇到开括号时，深度增加一，而当开括号时，深度减少一。每当我们遇到右方括号时，将所需的答案增加一个，然后再在此深度处将已经形成的平衡子字符串增加所需的答案。

下面是上述方法的实现：

C++

// CPP program to find number of
// balanced parenthesis sub strings
#include 
using namespace std;
  
// Function to find number of
// balanced parenthesis sub strings
int Balanced_Substring(string str, int n)
{
    // To store required answer
    int ans = 0;
  
    // Vector to stores the number of
    // balanced brackets at each depth.
    vector arr(n / 2 + 1, 0);
  
    // d strores checks the depth of our sequence
    // For example level of () is 1
    // and that of (()) is 2.
    int d = 0;
    for (int i = 0; i < n; i++) {
        // If open bracket
        // increase depth
        if (str[i] == '(')
            d++;
  
        // If closing bracket
        else {
            if (d == 1) {
                for (int j = 2; j <= n / 2 + 1 && arr[j] != 0; j++)
                    arr[j] = 0;
            }
            ++ans;
            ans += arr[d];
            arr[d]++;
            d--;
        }
    }
  
    // Return the required answer
    return ans;
}
  
// Driver code
int main()
{
    string str = "()()()";
  
    int n = str.size();
  
    // Function call
    cout << Balanced_Substring(str, n);
  
    return 0;
}

Java

// Java program to find number of
// balanced parenthesis sub strings
class GFG {
  
    // Function to find number of
    // balanced parenthesis sub strings
    public static int Balanced_Substring(String str,
                                         int n)
    {
  
        // To store required answer
        int ans = 0;
  
        // Vector to stores the number of
        // balanced brackets at each depth.
        int[] arr = new int[n / 2 + 1];
  
        // d strores checks the depth of our sequence
        // For example level of () is 1
        // and that of (()) is 2.
        int d = 0;
        for (int i = 0; i < n; i++) {
  
            // If open bracket
            // increase depth
            if (str.charAt(i) == '(')
                d++;
  
            // If closing bracket
            else {
                if (d == 1) {
                    for (int j = 2; j <= n / 2 + 1 && arr[j] != 0; j++)
                        arr[j] = 0;
                }
                ++ans;
                ans += arr[d];
                arr[d]++;
                d--;
            }
        }
  
        // Return the required answer
        return ans;
    }
  
    // Driver code
    public static void main(String[] args)
    {
        String str = "()()()";
        int n = str.length();
  
        // Function call
        System.out.println(Balanced_Substring(str, n));
    }
}
  
// This code is contributed by
// sanjeev2552

Python3

# Python3 program to find number of 
# balanced parenthesis sub strings 
  
# Function to find number of
# balanced parenthesis sub strings
def Balanced_Substring(s, n):
  
    # To store required answer
    ans = 0;
  
    # Vector to stores the number of
    # balanced brackets at each depth.
    arr = [0] * (int(n / 2) + 1);
  
    # d strores checks the depth of our sequence
    # For example level of () is 1
    # and that of (()) is 2.
    d = 0;
    for i in range(n):
  
        # If open bracket
        # increase depth
        if (s[i] == '('):
            d += 1;
  
        # If closing bracket
        else:
            if (d == 1):
                j = 2
                while (j <= n//2 + 1 and arr[j] != 0):
                    arr[j] = 0
            ans += 1;
            ans += arr[d];
            arr[d] += 1;
            d -= 1;
  
    # Return the required answer
    return ans;
  
# Driver code
s = "()()()";
n = len(s);
  
# Function call
print(Balanced_Substring(s, n));
  
# This code contributed by Rajput-Ji

C#

// C# program to find number of
// balanced parenthesis sub strings
using System;
  
class GFG {
  
    // Function to find number of
    // balanced parenthesis sub strings
    public static int Balanced_Substring(String str,
                                         int n)
    {
  
        // To store required answer
        int ans = 0;
  
        // Vector to stores the number of
        // balanced brackets at each depth.
        int[] arr = new int[n / 2 + 1];
  
        // d strores checks the depth of our sequence
        // For example level of () is 1
        // and that of (()) is 2.
        int d = 0;
        for (int i = 0; i < n; i++) {
  
            // If open bracket
            // increase depth
            if (str[i] == '(')
                d++;
  
            // If closing bracket
            else {
                if (d == 1) {
                    for (int j = 2; j <= n / 2 + 1 && arr[j] != 0; j++)
                        arr[j] = 0;
                }
                ++ans;
                ans += arr[d];
                arr[d]++;
                d--;
            }
        }
  
        // Return the required answer
        return ans;
    }
  
    // Driver code
    public static void Main(String[] args)
    {
        String str = "()()()";
        int n = str.Length;
  
        // Function call
        Console.WriteLine(Balanced_Substring(str, n));
    }
}
  
// This code is contributed by Princi Singh

输出：

6

时间复杂度： O(N)