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”, “10” and “11”.
Among them, “10” and “01” have the same frequency of 0s and 1s.
Hence, the answer is 2.
Input: 4
Output: 6
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 permutations 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++ 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;
} |
// 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 |
# Python3 program to implement # the above approach MOD = 1000000007
# Function to calculate C(n, r) % MOD # DP based approach def nCrModp (n, r):
# Corner case
if (n % 2 = = 1 ):
return - 1
# Stores the last row
# of Pascal's Triangle
C = [ 0 ] * (r + 1 )
# Initialize top row
# of pascal triangle
C[ 0 ] = 1
# Construct Pascal's Triangle
# from top to bottom
for i in range ( 1 , n + 1 ):
# Fill current row with the
# help of previous row
for j in range ( min (i, r), 0 , - 1 ):
# 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 N = 6
print (nCrModp(N, N / / 2 ))
# This code is contributed by himanshu77 |
// 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 |
<script> // Javascript program for the above approach var MOD = 1000000007;
// Function to calculate C(n, r) % MOD
// DP based approach
function nCrModp(n , r) {
// Corner case
if (n % 2 == 1) {
return -1;
}
// Stores the last row
// of Pascal's Triangle
var C = Array(r + 1).fill(0);
// Initialize top row
// of pascal triangle
C[0] = 1;
// Construct Pascal's Triangle
// from top to bottom
for (i = 1; i <= n; i++) {
// Fill current row with the
// help of previous row
for (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
var N = 6;
document.write(nCrModp(N, N / 2));
// This code contributed by gauravrajput1 </script> |
20
Time Complexity: O(N2)
Space Complexity: O(N)