Count all indices of cyclic regular parenthesis

Given a string S of length N, consisting of only opening ‘(‘ and closing ‘)‘ parenthesis. The task is to find all indices ‘K‘ such that S[K…N-1] + S[0…K-1] is a regular parenthesis.
 

A regular parentheses string is either empty (“”), “(” + str1 + “)”, or str1 + str2, where str1 and str2 are regular parentheses strings.
For example: “”, “()”, “(())()”, and “(()(()))” are regular parentheses strings. 
 

Examples: 
 

Input: str = “)()(” 
Output:
Explanation: 
For K = 1, S = ()(), which is regular. 
For K = 3, S = ()(), which is regular.
Input: S = “())(” 
Output:
Explanation: 
For K = 3, S = (()), which is regular. 
 

 



Naive Approach: The naive approach is to split the given string str at every possible index(say K) and check whether str[K, N-1] + str[0, K-1] is palindromic or not. If yes then print that particular value of K.
Time Complexity: O(N2
Auxiliary Space: O(1)
Efficient Approach: The idea is to observe that if at any index(say K) where the count of closing brackets is greater than the count of opening brackets then that index is the possible index of splitting the string. Below are the steps: 
 

  1. The partition is only possible when the count the number of opening brackets must be equal to the number of closing brackets. Else we can’t form any partition to balanced the parenthesis.
  2. Create an auxiliary array(say aux[]) of size length of the string.
  3. Traverse the given string if character at any index(say i) is ‘(‘ then update aux[i] to 1 else update strong>aux[i] to -1.
  4. The frequency of the minimum element in the above auxiliary array is the required number of splitting(say at index K) to make S[K…N-1] + S[0…K-1] a regular parenthesis string.

Below is the implementation of the above approach:
 

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program for the above approach
  
#include <bits/stdc++.h>
using namespace std;
  
// Function to find all indices which
// cyclic shift leads to get
// balanced parenthesis
int countCyclicShifts(string& S, int n)
{
    int aux[n] = { 0 };
  
    // Create auxiliary array
    for (int i = 0; i < n; ++i) {
        if (S[i] == '(')
            aux[i] = 1;
        else
            aux[i] = -1;
    }
  
    // Finding prefix sum and
    // minimum element
    int mn = aux[0];
  
    for (int i = 1; i < n; ++i) {
        aux[i] += aux[i - 1];
  
        // Update the minimum element
        mn = min(mn, aux[i]);
    }
  
    // ChecK if count of '(' and
    // ')' are equal
    if (aux[n - 1] != 0)
        return 0;
  
    // Find count of minimum
    // element
    int count = 0;
  
    // Find the frequency of mn
    for (int i = 0; i < n; ++i) {
        if (aux[i] == mn)
            count++;
    }
  
    // Return the count
    return count;
}
  
// Driver Code
int main()
{
    // Given string S
    string S = ")()(";
  
    int N = S.length();
  
    // Function Call
    cout << countCyclicShifts(S, N);
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program for the above approach 
import java.util.*;
  
class GFG{
      
// Function to find all indices which 
// cyclic shift leads to get 
// balanced parenthesis 
static int countCyclicShifts(String S, int n)
{
      
    // Create auxiliary array
    int[] aux = new int[n]; 
      
    for(int i = 0; i < n; ++i) 
    {
       if (S.charAt(i) == '(')
           aux[i] = 1
       else
           aux[i] = -1;
    }
      
    // Finding prefix sum and 
    // minimum element
    int mn = aux[0];
      
    for(int i = 1; i < n; ++i)
    {
       aux[i] += aux[i - 1];
         
       // Update the minimum element 
       mn = Math.min(mn, aux[i]); 
    }
      
    // Check if count of '(' and ')'
    // are equal 
    if (aux[n - 1] != 0
        return 0
      
    // Find count of minimum 
    // element 
    int count = 0
      
    // Find the frequency of mn 
    for(int i = 0; i < n; ++i)
    {
       if (aux[i] == mn) 
           count++; 
    }
      
    // Return the count 
    return count;
}
  
// Driver code 
public static void main(String[] args) 
{
      
    // Given string S 
    String S = ")()("
          
    // length of the string S 
    int N = S.length();
          
    System.out.print(countCyclicShifts(S, N));
}
}
  
// This code is contributed by sanjoy_62

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program for the above approach
  
# Function to find all indices which
# cyclic shift leads to get
# balanced parenthesis
def countCyclicShifts(S, n):
      
    aux = [0 for i in range(n)]
  
    # Create auxiliary array
    for i in range(0, n):
        if (S[i] == '('):
            aux[i] = 1
        else:
            aux[i] = -1
  
    # Finding prefix sum and
    # minimum element
    mn = aux[0]
  
    for i in range(1, n):
        aux[i] += aux[i - 1]
  
        # Update the minimum element
        mn = min(mn, aux[i])
  
    # ChecK if count of '(' and
    # ')' are equal
    if (aux[n - 1] != 0):
        return 0
  
    # Find count of minimum
    # element
    count = 0
  
    # Find the frequency of mn
    for i in range(0, n):
        if (aux[i] == mn):
            count += 1
  
    # Return the count
    return count
  
# Driver Code
  
# Given string S
S = ")()("
N = len(S)
  
# Function call
print(countCyclicShifts(S, N))
  
# This code is contributed by Sanjit_Prasad

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach 
using System;
  
class GFG{
      
// Function to find all indices which 
// cyclic shift leads to get 
// balanced parenthesis 
static int countCyclicShifts(string S, int n)
{
      
    // Create auxiliary array
    int[] aux = new int[n]; 
      
    for(int i = 0; i < n; ++i) 
    {
        if (S[i] == '(')
            aux[i] = 1; 
        else
            aux[i] = -1;
    }
      
    // Finding prefix sum and 
    // minimum element
    int mn = aux[0];
      
    for(int i = 1; i < n; ++i)
    {
        aux[i] += aux[i - 1];
              
        // Update the minimum element 
        mn = Math.Min(mn, aux[i]); 
    }
      
    // Check if count of '(' and ')'
    // are equal 
    if (aux[n - 1] != 0) 
        return 0; 
      
    // Find count of minimum 
    // element 
    int count = 0; 
      
    // Find the frequency of mn 
    for(int i = 0; i < n; ++i)
    {
        if (aux[i] == mn) 
            count++; 
    }
      
    // Return the count 
    return count;
}
  
// Driver code 
public static void Main(string[] args) 
{
      
    // Given string S 
    string S = ")()("
          
    // length of the string S 
    int N = S.Length;
          
    Console.Write(countCyclicShifts(S, N));
}
}
  
// This code is contributed by rutvik_56

chevron_right


Output:

2

Time Complexity: O(N), where N is the length of the string. 
Auxiliary Space: O(N), where N is the length of the string.

competitive-programming-img




My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.