Open In App

Count of all possible N length balanced Binary Strings

Last Updated : 24 Mar, 2023
Improve
Improve
Like Article
Like
Save
Share
Report

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:

  1. If N is odd, then no balanced binary string is possible as the condition of an equal count of 0s and 1s will fail.
  2. If N is even, then the N length binary string will have N/2 balanced pair of 0s and 1s.
  3. 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.

  1. Hence for any even N return Catalan number for (N/2) as the answer.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
  
#include <bits/stdc++.h>
using namespace std;
  
#define MAXN 500
#define mod 1000000007
  
// Vector to store catalan number
vector<long long int> cat(MAXN + 1, 0);
  
// Function to get the Catalan Number
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 is odd
    if (N & 1) {
        return 0;
    }
  
    // Returning Catalan number
    // of N/2 as the answer
    return cat[N / 2];
}
  
// Driver Code
int main()
{
    // Precomputing
    catalan();
  
    int N = 4;
    cout << countBalancedStrings(N);
}


Java




// Java program for the above approach
import java.io.*;
class GFG {
  
    public static int MAXN = 500;
    public static int mod = 1000000007;
  
    // Vector to store catalan number
    public static int[] cat = new int[MAXN + 1];
  
    // Function to get the Catalan Number
    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 is odd
        if ((N & 1) > 0) {
            return 0;
        }
  
        // Returning Catalan number
        // of N/2 as the answer
        return cat[N / 2];
    }
  
    // Driver Code
    public static void main(String args[])
    {
        
        // Precomputing
        catalan();
  
        int N = 4;
        System.out.println(countBalancedStrings(N));
    }
}
  
// This code is contributed by saurabh_jaiswal.


Python3




# Python3 program for the above approach
MAXN = 500
mod = 1000000007
  
# Vector to store catalan number
cat = [0 for _ in range(MAXN + 1)]
  
# Function to get the Catalan Number
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 is odd
    if (N & 1):
        return 0
  
    # Returning Catalan number
    # of N/2 as the answer
    return cat[N // 2]
  
# Driver Code
if __name__ == "__main__":
  
    # Precomputing
    catalan()
  
    N = 4
    print(countBalancedStrings(N))
  
# This code is contributed by rakeshsahni


C#




// C# program for the above approach
using System;
class GFG
{
    public static int MAXN = 500;
    public static int mod = 1000000007;
  
    // Vector to store catalan number
    public static int[] cat = new int[MAXN + 1];
  
    // Function to get the Catalan Number
    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 is odd
        if ((N & 1) > 0)
        {
            return 0;
        }
  
        // Returning Catalan number
        // of N/2 as the answer
        return cat[N / 2];
    }
  
    // Driver Code
    public static void Main()
    {
  
        // Precomputing
        catalan();
  
        int N = 4;
        Console.Write(countBalancedStrings(N));
    }
}
  
// This code is contributed by saurabh_jaiswal.


Javascript




<script>
 
    // JavaScript Program to implement
    // the above approach 
    let MAXN = 500
    let mod = 1000000007
 
    // Vector to store catalan number
    let cat = new Array(MAXN + 1).fill(0);
 
    // Function to get the Catalan Number
    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 is odd
        if (N & 1) {
            return 0;
        }
 
        // Returning Catalan number
        // of N/2 as the answer
        return cat[(Math.floor(N / 2))];
    }
 
    // Driver Code
 
    // Precomputing
    catalan();
    let N = 4;
    document.write(countBalancedStrings(N));
 
// This code is contributed by Potta Lokesh
</script>


Output

2

Time Complexity: O(N2)
Auxiliary Space: O(N)

 



Similar Reads

Count of binary strings of length N having equal count of 0's and 1's and count of 1's &ge; count of 0's in each prefix substring
Given an integer N, the task is to find the number of possible binary strings of length N with an equal frequency of 0's and 1's in which frequency of 1's are greater or equal to the frequency of 0's in every prefix substring. Examples: Input: N = 2Output: 1Explanation:All possible binary strings of length 2 are {"00", "01", "10" and "11"}. Out of
7 min read
Comparison between Height Balanced Tree and Weight Balanced Tree
What is Height Balanced Tree? Self-Balancing binary search trees are the height-balanced binary tree is one for which at every node, the absolute value of the difference in heights of the left and right subtree is no larger than one. An empty tree is height-balanced. A non-empty binary tree T is balanced if: The left subtree of T is balanced.The ri
4 min read
Count possible binary strings of length N without P consecutive 0s and Q consecutive 1s
Given three integers N, P, and Q, the task is to count all possible distinct binary strings of length N such that each binary string does not contain P times consecutive 0’s and Q times consecutive 1's. Examples: Input: N = 5, P = 2, Q = 3Output: 7Explanation: Binary strings that satisfy the given conditions are { “01010”, “01011”, “01101”, “10101”
19 min read
Maximum possible balanced binary substring splits with at most cost K
Given a binary array arr[] and a value array val[]. The task is to find the maximum possible splits of the binary array that can be done such that each segment contains an equal number of 0s and 1s using at most k coins. Each split costs (val[i] - val[j])2, where i and j are the adjacent indices of the split segment. Examples: Input: arr[] = {0, 1,
9 min read
Count of binary strings of length N with even set bit count and at most K consecutive 1s
Given two integers N and K, the task is to find the number of binary strings of length N having an even number of 1's out of which less than K are consecutive.Examples: Input: N = 4, K = 2 Output: 4 Explanation: The possible binary strings are 0000, 0101, 1001, 1010. They all have even number of 1's with less than 2 of them occurring consecutively.
12 min read
Count of binary strings of length N having equal count of 0's and 1's
Given an integer N, the task is to find the number of binary strings possible of length N having same frequency of 0s and 1s. If such string is possible of length N, print -1. Note: Since the count can be very large, return the answer modulo 109+7.Examples: Input: N = 2 Output: 2 Explanation: All possible binary strings of length 2 are "00", "01",
6 min read
Count of Binary Strings of length at most N with set bit count as multiple of K
Given two integers N and K, the task is to find the count of binary strings of at most N length that can be formed such that the count of consecutive 1's is always a multiple of K. Example: Input: N = 3, K = 2Output: 6Explanation: Binary strings of atmost N length containing consecutive 1's as a multiple of K are as follows: Length 1: "0", contains
7 min read
Count number of binary strings such that there is no substring of length greater than or equal to 3 with all 1's
Given an integer N, the task is to count the number of binary strings possible of length N such that they don't contain "111" as a substring. The answer could be large so print answer modulo 109 + 7.Examples: Input: N = 3 Output: 7 All possible substring are "000", "001", "010", "011", "100", "101" and "110". "111" is not a valid string.Input N = 1
6 min read
Generate all Binary Strings of length N with equal count of 0s and 1s
Given an integer N, the task is to generate all the binary strings with equal 0s and 1s. If no strings are possible, print -1 Examples: Input: N = 2 Output: “01”, “10”Explanation: All possible binary strings of length 2 are: 01, 10, 11, 00. Out of these, only 2 have equal number of 0s and 1s Input: 4 Output: “0011”, “0101”, “0110”, “1100”, “1010”,
6 min read
Print all Balanced Brackets Strings that can be formed by replacing wild card '?'
Given string str containing characters '?', '(' and ')', the task is to replace the '?' character with '(' or ')' and print all the strings containing balanced brackets Example: Input: str = "????"Output:()()(()) Input: str = "(()?"Output: (()) Approach: The given problem can be solved using recursion and backtracking. The idea is to substitute eve
10 min read