Given an integer N, the task is to find the number of distinct bracket sequences that can be formed using 2 * N brackets such that the sequence is not N-periodic.
A bracket sequence str of length 2 * N is said to be N-periodic if the sequence can be split into two equal substrings having same regular bracket sequence.
A regular bracket sequence is a sequence in the following way:
- An empty string is a regular bracket sequence.
- If s & t are regular bracket sequences, then s + t is a regular bracket sequence.
Examples:
Input: N = 3
Output: 5
Explanation:
There will be 5 distinct regular bracket sequences of length 2 * N = ()()(), ()(()), (())(), (()()), ((()))
Now, none of the sequences are N-periodic. Therefore, the output is 5.Input: N = 4
Output: 12
Explanation:
There will be 14 distinct regular bracket sequences of length 2*N which are
()()()(), ()()(()), ()(())(), ()(()()), ()((())), (())()(), (())(()), (()())(), (()()()), (()(())), ((()))(), ((())()), ((()())), (((())))
Out of these 14 regular sequences, two of them are N periodic which are
()()()() and (())(()). They have a period of N.
Therefore, the distinct regular bracket sequences of length 2 * N which are not N-periodic are 14 – 2 = 12.
Approach: The idea is to calculate the total number of regular bracket sequences possible of length 2 * N and then to subtract the number of bracket sequences which are N-periodic from it. Below are the steps:
- To find the number of regular bracket sequences of length 2*N, use the Catalan number formula.
- For a sequence of length 2*N to be N periodic, N should be even because if N is odd then the sequence of length 2*N cannot be a regular sequence and have a period of N at the same time.
- Since the concatenation of two similar non-regular bracket sequences cannot make a sequence regular, so both subsequences of length N should be regular.
- Reduce the number of regular bracket sequences of length N(if N is even) from the number of regular bracket sequences of length 2*N to get the desired result.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function that finds the value of // Binomial Coefficient C(n, k) unsigned long int
binomialCoeff(unsigned int n,
unsigned int k)
{ unsigned long int res = 1;
// Since C(n, k) = C(n, n - k)
if (k > n - k)
k = n - k;
// Calculate the value of
// [n*(n - 1)*---*(n - k + 1)] /
// [k*(k - 1)*---*1]
for ( int i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
// Return the C(n, k)
return res;
} // Binomial coefficient based function to // find nth catalan number in O(n) time unsigned long int catalan(unsigned int n)
{ // Calculate value of 2nCn
unsigned long int c
= binomialCoeff(2 * n, n);
// Return C(2n, n)/(n+1)
return c / (n + 1);
} // Function to find possible ways to // put balanced parenthesis in an // expression of length n unsigned long int findWays(unsigned n)
{ // If n is odd, not possible to
// create any valid parentheses
if (n & 1)
return 0;
// Otherwise return n/2th
// Catalan Number
return catalan(n / 2);
} void countNonNPeriodic( int N)
{ // Difference between counting ways
// of 2*N and N is the result
cout << findWays(2 * N)
- findWays(N);
} // Driver Code int main()
{ // Given value of N
int N = 4;
// Function Call
countNonNPeriodic(N);
return 0;
} |
// Java program for above approach import java.io.*;
class GFG{
// Function that finds the value of // Binomial Coefficient C(n, k) static long binomialCoeff( int n, int k)
{ long res = 1 ;
// Since C(n, k) = C(n, n - k)
if (k > n - k)
k = n - k;
// Calculate the value of
// [n*(n - 1)*---*(n - k + 1)] /
// [k*(k - 1)*---*1]
for ( int i = 0 ; i < k; ++i)
{
res *= (n - i);
res /= (i + 1 );
}
// Return the C(n, k)
return res;
} // Binomial coefficient based function to // find nth catalan number in O(n) time static long catalan( int n)
{ // Calculate value of 2nCn
long c = binomialCoeff( 2 * n, n);
// Return C(2n, n)/(n+1)
return c / (n + 1 );
} // Function to find possible ways to // put balanced parenthesis in an // expression of length n static long findWays( int n)
{ // If n is odd, not possible to
// create any valid parentheses
if ((n & 1 ) == 1 )
return 0 ;
// Otherwise return n/2th
// Catalan Number
return catalan(n / 2 );
} static void countNonNPeriodic( int N)
{ // Difference between counting ways
// of 2*N and N is the result
System.out.println(findWays( 2 * N) -
findWays(N));
} // Driver code public static void main (String[] args)
{ // Given value of N
int N = 4 ;
// Function call
countNonNPeriodic(N);
} } // This code is contributed by offbeat |
# Python3 program for # the above approach # Function that finds the value of # Binomial Coefficient C(n, k) def binomialCoeff(n, k):
res = 1
# Since C(n, k) = C(n, n - k)
if (k > n - k):
k = n - k
# Calculate the value of
# [n*(n - 1)*---*(n - k + 1)] /
# [k*(k - 1)*---*1]
for i in range (k):
res = res * (n - i)
res = res / / (i + 1 )
# Return the C(n, k)
return res
# Binomial coefficient based function to # find nth catalan number in O(n) time def catalan(n):
# Calculate value of 2nCn
c = binomialCoeff( 2 * n, n)
# Return C(2n, n)/(n+1)
return c / / (n + 1 )
# Function to find possible ways to # put balanced parenthesis in an # expression of length n def findWays(n):
# If n is odd, not possible to
# create any valid parentheses
if ((n & 1 ) = = 1 ):
return 0
# Otherwise return n/2th
# Catalan Number
return catalan(n / / 2 )
def countNonNPeriodic(N):
# Difference between counting ways
# of 2*N and N is the result
print (findWays( 2 * N) - findWays(N))
# Driver code # Given value of N N = 4
# Function call countNonNPeriodic(N) # This code is contributed by divyeshrabadiya07 |
// C# program for above approach using System;
using System.Collections.Generic;
class GFG{
// Function that finds the value of // Binomial Coefficient C(n, k) static long binomialCoeff( int n, int k)
{ long res = 1;
// Since C(n, k) = C(n, n - k)
if (k > n - k)
k = n - k;
// Calculate the value of
// [n*(n - 1)*---*(n - k + 1)] /
// [k*(k - 1)*---*1]
for ( int i = 0; i < k; ++i)
{
res *= (n - i);
res /= (i + 1);
}
// Return the C(n, k)
return res;
} // Binomial coefficient based function to // find nth catalan number in O(n) time static long catalan( int n)
{ // Calculate value of 2nCn
long c = binomialCoeff(2 * n, n);
// Return C(2n, n)/(n+1)
return c / (n + 1);
} // Function to find possible ways to // put balanced parenthesis in an // expression of length n static long findWays( int n)
{ // If n is odd, not possible to
// create any valid parentheses
if ((n & 1) == 1)
return 0;
// Otherwise return n/2th
// Catalan Number
return catalan(n / 2);
} static void countNonNPeriodic( int N)
{ // Difference between counting ways
// of 2*N and N is the result
Console.Write(findWays(2 * N) -
findWays(N));
} // Driver Code public static void Main( string [] args)
{ // Given value of N
int N = 4;
// Function call
countNonNPeriodic(N);
} } // This code is contributed by rutvik_56 |
<script> // Javascript program for the above approach // Function that finds the value of // Binomial Coefficient C(n, k) function binomialCoeff(n, k)
{ let res = 1;
// Since C(n, k) = C(n, n - k)
if (k > n - k)
k = n - k;
// Calculate the value of
// [n*(n - 1)*---*(n - k + 1)] /
// [k*(k - 1)*---*1]
for (let i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
// Return the C(n, k)
return res;
} // Binomial coefficient based function to // find nth catalan number in O(n) time function catalan(n)
{ // Calculate value of 2nCn
let c = binomialCoeff(2 * n, n);
// Return C(2n, n)/(n+1)
return c / (n + 1);
} // Function to find possible ways to // put balanced parenthesis in an // expression of length n function findWays(n)
{ // If n is odd, not possible to
// create any valid parentheses
if (n & 1)
return 0;
// Otherwise return n/2th
// Catalan Number
return catalan(n / 2);
} function countNonNPeriodic(N)
{ // Difference between counting ways
// of 2*N and N is the result
document.write(findWays(2 * N)
- findWays(N));
} // Driver Code // Given value of N
let N = 4;
// Function Call
countNonNPeriodic(N);
// This code is contributed by Mayank Tyagi </script> |
12
Time Complexity: O(N)
Auxiliary Space: O(1)