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:
Explanation: 
All possible binary strings of length 2 are “00”, “01”, “10” and “11”. 
Among them, “10” and “01” have the same frequency of 0s and 1s. 
Hence, the answer is 2.
Input:
Output:
Explanation: 
Strings “0011”, “0101”, “0110”, “1100”, “1010” and “1001” have same frequency of 0s and 1s. 
Hence, the answer is 6. 
 

 

Naive Approach: 
The simplest approach is to generate all possible permutations of a string of length N having equal number of ‘0’ and ‘1’. For every permutation generated, increase the count. Print the total count of permutatiosn generated. 
Time Complexity: O(N*N!) 
Auxiliary Space: O(N)
Efficient Approach: 
The above approach can be optimized by using concepts of Permutation and Combination. Follow the steps below to solve the problem: 
 

  • Since N positions need to be filled with equal number of 0‘s and 1‘s, select N/2 positions from the N positions in C(N, N/2) % mod( where mod = 109 + 7) ways to fill with only 1’s.
  • Fill the remaining positions in C(N/2, N/2) % mod (i.e 1) way with only 0’s.

Below is the implementation of the above approach:
 



C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ Program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
#define MOD 1000000007
  
// Function to calculate C(n, r) % MOD
// DP based approach
int nCrModp(int n, int r)
{
    // Corner case
    if (n % 2 == 1) {
        return -1;
    }
  
    // Stores the last row
    // of Pascal's Triangle
    int C[r + 1];
  
    memset(C, 0, sizeof(C));
  
    // Initialize top row
    // of pascal triangle
    C[0] = 1;
  
    // Construct Pascal's Triangle
    // from top to bottom
    for (int i = 1; i <= n; i++) {
  
        // Fill current row with the
        // help of previous row
        for (int j = min(i, r); j > 0;
            j--)
  
            // C(n, j) = C(n-1, j)
            // + C(n-1, j-1)
            C[j] = (C[j] + C[j - 1])
                % MOD;
    }
  
    return C[r];
}
  
// Driver Code
int main()
{
    int N = 6;
    cout << nCrModp(N, N / 2);
    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{
      
final static int MOD = 1000000007;
      
// Function to calculate C(n, r) % MOD
// DP based approach
static int nCrModp(int n, int r)
{
  
    // Corner case
    if (n % 2 == 1)
    {
        return -1;
    }
  
    // Stores the last row
    // of Pascal's Triangle
    int C[] = new int[r + 1];
  
    Arrays.fill(C, 0);
  
    // Initialize top row
    // of pascal triangle
    C[0] = 1;
  
    // Construct Pascal's Triangle
    // from top to bottom
    for(int i = 1; i <= n; i++)
    {
  
        // Fill current row with the
        // help of previous row
        for(int j = Math.min(i, r); 
                j > 0; j--)
  
            // C(n, j) = C(n-1, j)
            // + C(n-1, j-1)
            C[j] = (C[j] + C[j - 1]) % MOD;
    }
    return C[r];
}
  
// Driver Code
public static void main(String s[])
{
    int N = 6;
    System.out.println(nCrModp(N, N / 2));
}
  
// This code is contributed by rutvik_56

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program for the above approach
using System;
  
class GFG{
      
static int MOD = 1000000007;
  
// Function to calculate C(n, r) % MOD
// DP based approach
static int nCrModp(int n, int r)
{
      
    // Corner case
    if (n % 2 == 1)
    {
        return -1;
    }
  
    // Stores the last row
    // of Pascal's Triangle
    int[] C = new int[r + 1];
  
    // Initialize top row
    // of pascal triangle
    C[0] = 1;
  
    // Construct Pascal's Triangle
    // from top to bottom
    for(int i = 1; i <= n; i++)
    {
  
        // Fill current row with the
        // help of previous row
        for(int j = Math.Min(i, r); 
                j > 0; j--)
  
            // C(n, j) = C(n-1, j)
            // + C(n-1, j-1)
            C[j] = (C[j] + C[j - 1]) % MOD;
    }
    return C[r];
}
  
// Driver code
static void Main() 
{
    int N = 6;
    Console.WriteLine(nCrModp(N, N / 2));
}
}
  
// This code is contributed by divyeshrabadiya07

chevron_right


Output: 

20

 

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.




My Personal Notes arrow_drop_up

Recommended Posts:


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.