Count of all possible N length balanced Binary Strings
Last Updated :
24 Mar, 2023
Given a number N, the task is to find the total number of balanced binary strings possible of length N. A binary string is said to be balanced if:
- The number of 0s and 1s are equal in each binary string
- The count of 0s in any prefix of binary strings is always greater than or equal to the count of 1s
- For Example: 01 is a balanced binary string of length 2, but 10 is not.
Example:
Input: N = 4
Output: 2
Explanation: Possible balanced binary strings are: 0101, 0011
Input: N = 5
Output: 0
Approach: The given problem can be solved as below:
- If N is odd, then no balanced binary string is possible as the condition of an equal count of 0s and 1s will fail.
- If N is even, then the N length binary string will have N/2 balanced pair of 0s and 1s.
- So, now try to create a formula to get the number of balanced strings when N is even.
So if N = 2, then possible balanced binary string will be “01” only, as “00” and “11” do not have same count of 0s and 1s and “10” does not have count of 0s >= count of 1s in prefix [0, 1).
Similarly, if N=4, then possible balanced binary string will be “0101” and “0011”
For N = 6, then possible balanced binary string will be “010101”, “010011”, “001101”, “000111”, and “001011”
Now, If we consider this series:
For N=0, count(0) = 1
For N=2, count(2) = count(0)*count(0) = 1
For N=4, count(4) = count(0)*count(2) + count(2)*count(0) = 1*1 + 1*1 = 2
For N=6, count(6) = count(0)*count(4) + count(2)*count(2) + count(4)*count(0) = 1*2 + 1*1 + 2*1 = 5
For N=8, count(8) = count(0)*count(6) + count(2)*count(4) + count(4)*count(2) + count(6)*count(0) = 1*5 + 1*2 + 2*1 + 5*1 = 14
.
.
.
For N=N, count(N) = count(0)*count(N-2) + count(2)*count(N-4) + count(4)*count(N-6) + …. + count(N-6)*count(4) + count(N-4)*count(2) + count(N-2)*count(0)
which is nothing but Catalan numbers.
- Hence for any even N return Catalan number for (N/2) as the answer.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
#define MAXN 500
#define mod 1000000007
vector< long long int > cat(MAXN + 1, 0);
void catalan()
{
cat[0] = 1;
cat[1] = 1;
for ( int i = 2; i < MAXN + 1; i++) {
long long int t = 0;
for ( int j = 0; j < i; j++) {
t += ((cat[j] % mod)
* (cat[i - 1 - j] % mod)
% mod);
}
cat[i] = (t % mod);
}
}
int countBalancedStrings( int N)
{
if (N & 1) {
return 0;
}
return cat[N / 2];
}
int main()
{
catalan();
int N = 4;
cout << countBalancedStrings(N);
}
|
Java
import java.io.*;
class GFG {
public static int MAXN = 500 ;
public static int mod = 1000000007 ;
public static int [] cat = new int [MAXN + 1 ];
public static void catalan() {
cat[ 0 ] = 1 ;
cat[ 1 ] = 1 ;
for ( int i = 2 ; i < MAXN + 1 ; i++) {
int t = 0 ;
for ( int j = 0 ; j < i; j++) {
t += ((cat[j] % mod)
* (cat[i - 1 - j] % mod)
% mod);
}
cat[i] = (t % mod);
}
}
public static int countBalancedStrings( int N)
{
if ((N & 1 ) > 0 ) {
return 0 ;
}
return cat[N / 2 ];
}
public static void main(String args[])
{
catalan();
int N = 4 ;
System.out.println(countBalancedStrings(N));
}
}
|
Python3
MAXN = 500
mod = 1000000007
cat = [ 0 for _ in range (MAXN + 1 )]
def catalan():
global cat
cat[ 0 ] = 1
cat[ 1 ] = 1
for i in range ( 2 , MAXN + 1 ):
t = 0
for j in range ( 0 , i):
t + = ((cat[j] % mod) *
(cat[i - 1 - j] % mod) % mod)
cat[i] = (t % mod)
def countBalancedStrings(N):
if (N & 1 ):
return 0
return cat[N / / 2 ]
if __name__ = = "__main__" :
catalan()
N = 4
print (countBalancedStrings(N))
|
C#
using System;
class GFG
{
public static int MAXN = 500;
public static int mod = 1000000007;
public static int [] cat = new int [MAXN + 1];
public static void catalan()
{
cat[0] = 1;
cat[1] = 1;
for ( int i = 2; i < MAXN + 1; i++)
{
int t = 0;
for ( int j = 0; j < i; j++)
{
t += ((cat[j] % mod)
* (cat[i - 1 - j] % mod)
% mod);
}
cat[i] = (t % mod);
}
}
public static int countBalancedStrings( int N)
{
if ((N & 1) > 0)
{
return 0;
}
return cat[N / 2];
}
public static void Main()
{
catalan();
int N = 4;
Console.Write(countBalancedStrings(N));
}
}
|
Javascript
<script>
let MAXN = 500
let mod = 1000000007
let cat = new Array(MAXN + 1).fill(0);
function catalan() {
cat[0] = 1;
cat[1] = 1;
for (let i = 2; i < MAXN + 1; i++) {
let t = 0;
for (let j = 0; j < i; j++) {
t += ((cat[j] % mod)
* (cat[i - 1 - j] % mod)
% mod);
}
cat[i] = (t % mod);
}
}
function countBalancedStrings(N)
{
if (N & 1) {
return 0;
}
return cat[(Math.floor(N / 2))];
}
catalan();
let N = 4;
document.write(countBalancedStrings(N));
</script>
|
Time Complexity: O(N2)
Auxiliary Space: O(N)
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...