Skip to content
Related Articles

Related Articles

Count of binary strings of length N with even set bit count and at most K consecutive 1s

View Discussion
Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 16 Jun, 2022

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.
Input: N = 3, K = 2 
Output: 2 
Explanation: 
The possible binary strings are 000, 101. All other strings that is 001, 010, 011, 100, 110, 111 does not meet the criteria.

Approach: 
This problem can be solved by Dynamic Programming.
Let us consider a 3D table dp[][][] to store the solution of each subproblem, such that, dp[n][i][s] denotes the number of binary strings of length n having i consecutive 1’s and sum of 1’s = s. As it is only required to check whether the total number of 1’s is even or not we store s % 2. So, dp[n][i][s] can be calculated as follows: 
 

  1. If we place 0 at the nth position, the number of 1’s remain unchanged. Hence, dp[n][i][s] = dp[n – 1][0][s].
  2. If we place 1 at the nth position, dp[n][i][s] = dp[n – 1][i + 1][(s + 1) % 2] .
  3. From the above two points the recurrence relation formed is given by: 
     

dp[n][i][s] = dp[n-1][0][s] + dp[n - 1][i + 1][(s + 1)mod 2]

Below is the implementation of the above approach:
 

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Table to store solution
// of each subproblem
int dp[100001][20][2];
 
// Function to calculate
// the possible binary
// strings
int possibleBinaries(int pos,
                     int ones,
                     int sum,
                     int k)
{
    // If number of ones
    // is equal to K
    if (ones == k)
        return 0;
 
    // pos: current position
    // Base Case: When n
    // length is traversed
    if (pos == 0)
 
        // sum: count of 1's
        // Return the count
        // of 1's obtained
        return (sum == 0) ? 1 : 0;
 
    // If the subproblem has already
    // been solved
    if (dp[pos][ones][sum] != -1)
        // Return the answer
        return dp[pos][ones][sum];
 
    // Recursive call when current
    // position is filled with 1
    int ret = possibleBinaries(pos - 1,
                               ones + 1,
                               (sum + 1) % 2,
                               k)
              // Recursive call when current
              // position is filled with 0
              + possibleBinaries(pos - 1, 0,
                                 sum, k);
 
    // Store the solution
    // to this subproblem
    dp[pos][ones][sum] = ret;
 
    return dp[pos][ones][sum];
}
 
// Driver Code
int main()
{
    int N = 3;
    int K = 2;
 
    // Initialising the
    // table with -1
    memset(dp, -1, sizeof dp);
 
    cout << possibleBinaries(N, 0, 0, K);
}

Java



// Java program for the above approach
class GFG{
 
// Table to store solution
// of each subproblem
static int [][][]dp = new int[100001][20][2];
 
// Function to calculate
// the possible binary
// Strings
static int possibleBinaries(int pos, int ones,
                            int sum, int k)
{
     
    // If number of ones
    // is equal to K
    if (ones == k)
        return 0;
 
    // pos: current position
    // Base Case: When n
    // length is traversed
    if (pos == 0)
 
        // sum: count of 1's
        // Return the count
        // of 1's obtained
        return (sum == 0) ? 1 : 0;
 
    // If the subproblem has already
    // been solved
    if (dp[pos][ones][sum] != -1)
     
        // Return the answer
        return dp[pos][ones][sum];
 
    // Recursive call when current
    // position is filled with 1
    int ret = possibleBinaries(pos - 1,
                              ones + 1,
                              (sum + 1) % 2, k) +
                               
              // Recursive call when current
              // position is filled with 0
              possibleBinaries(pos - 1, 0,
                               sum, k);
                                
    // Store the solution
    // to this subproblem
    dp[pos][ones][sum] = ret;
 
    return dp[pos][ones][sum];
}
 
// Driver Code
public static void main(String[] args)
{
    int N = 3;
    int K = 2;
 
    // Initialising the
    // table with -1
    for(int i = 0; i < 100001; i++)
    {
        for(int j = 0; j < 20; j++)
        {
            for(int l = 0; l < 2; l++)
                dp[i][j][l] = -1;
        }
    }
 
    System.out.print(possibleBinaries(N, 0, 0, K));
}
}
 
// This code is contributed by Rohit_ranjan
Python3



# Python3 program for the above approach
import numpy as np
 
# Table to store solution
# of each subproblem
dp = np.ones(((100002, 21, 3)))
dp = -1 * dp
 
# Function to calculate
# the possible binary
# strings
def possibleBinaries(pos, ones, sum, k):
     
    # If number of ones
    # is equal to K
    if (ones == k):
        return 0
 
    # pos: current position
    # Base Case: When n
    # length is traversed
    if (pos == 0):
 
        # sum: count of 1's
        # Return the count
        # of 1's obtained
        return 1 if (sum == 0) else 0
 
    # If the subproblem has already
    # been solved
    if (dp[pos][ones][sum] != -1):
         
        # Return the answer
        return dp[pos][ones][sum]
 
    # Recursive call when current
    # position is filled with 1
    ret = (possibleBinaries(pos - 1,
                           ones + 1,
                           (sum + 1) % 2, k) +
     
           # Recursive call when current
           # position is filled with 0
           possibleBinaries(pos - 1, 0, sum, k))
 
    # Store the solution
    # to this subproblem
    dp[pos][ones][sum] = ret
 
    return dp[pos][ones][sum]
 
# Driver Code
N = 3
K = 2
             
print(int(possibleBinaries(N, 0, 0, K)))
 
# This code is contributed by sanjoy_62
C#



// C# program for the above approach
using System;
 
class GFG{
 
// Table to store solution
// of each subproblem
static int [,,]dp = new int[100001, 20, 2];
 
// Function to calculate the
// possible binary Strings
static int possibleBinaries(int pos, int ones,
                            int sum, int k)
{
     
    // If number of ones
    // is equal to K
    if (ones == k)
        return 0;
 
    // pos: current position
    // Base Case: When n
    // length is traversed
    if (pos == 0)
 
        // sum: count of 1's
        // Return the count
        // of 1's obtained
        return (sum == 0) ? 1 : 0;
 
    // If the subproblem has already
    // been solved
    if (dp[pos, ones, sum] != -1)
     
        // Return the answer
        return dp[pos, ones, sum];
 
    // Recursive call when current
    // position is filled with 1
    int ret = possibleBinaries(pos - 1,
                                ones + 1,
                                (sum + 1) % 2, k) +
              // Recursive call when current
              // position is filled with 0
              possibleBinaries(pos - 1, 0,
                               sum, k);
                                
    // Store the solution
    // to this subproblem
    dp[pos, ones, sum] = ret;
 
    return dp[pos, ones, sum];
}
 
// Driver Code
public static void Main(String[] args)
{
    int N = 3;
    int K = 2;
 
    // Initialising the
    // table with -1
    for(int i = 0; i < 100001; i++)
    {
        for(int j = 0; j < 20; j++)
        {
            for(int l = 0; l < 2; l++)
                dp[i, j, l] = -1;
        }
    }
    Console.Write(possibleBinaries(N, 0, 0, K));
}
}
 
// This code is contributed by Amit Katiyar
Javascript



<script>
// Javascript program for the above approach
 
// Table to store solution
// of each subproblem
let dp = new Array(100001).fill(-1).map((t) => new Array(20).fill(-1).map((r) => new Array(2).fill(-1)));
 
// Function to calculate
// the possible binary
// strings
function possibleBinaries(pos, ones, sum, k)
{
 
    // If number of ones
    // is equal to K
    if (ones == k)
        return 0;
 
    // pos: current position
    // Base Case: When n
    // length is traversed
    if (pos == 0)
 
        // sum: count of 1's
        // Return the count
        // of 1's obtained
        return (sum == 0) ? 1 : 0;
 
    // If the subproblem has already
    // been solved
    if (dp[pos][ones][sum] != -1)
        // Return the answer
        return dp[pos][ones][sum];
 
    // Recursive call when current
    // position is filled with 1
    let ret = possibleBinaries(pos - 1,
        ones + 1,
        (sum + 1) % 2,
        k)
         
        // Recursive call when current
        // position is filled with 0
        + possibleBinaries(pos - 1, 0,
            sum, k);
 
    // Store the solution
    // to this subproblem
    dp[pos][ones][sum] = ret;
 
    return dp[pos][ones][sum];
}
 
// Driver Code
let N = 3;
let K = 2;
 
// Initialising the
// table with -1
document.write(possibleBinaries(N, 0, 0, K));
 
// This code is contributed by _saurabh_jaiswal
</script>
Output: 
2
 
Time Complexity: O(2*N*K), where N and K represents the given two integers.
 Auxiliary Space: O(100001*20*2), no any other extra space is required, so it is a constant.

My Personal Notes
arrow_drop_up
Previous
Product of all Subarrays of an Array | Set 2
Next

Check if it is possible to reach to the index with value K when start index is given
Recommended Articles
Page :
Count of Binary Strings of length at most N with set bit count as multiple of K
22, Oct 21
Count of Binary strings having at most X consecutive 1s and Y consecutive 0s
16, Jan 22
Count possible binary strings of length N without P consecutive 0s and Q consecutive 1s
09, Oct 20
Count bases which contains a set bit as the Most Significant Bit in the representation of N
18, Jun 21
Minimum bit flips such that every K consecutive bits contain at least one set bit
11, Jun 20
Generate a Binary String without any consecutive 0's and at most K consecutive 1's
29, Jul 20
Count of 1-bit and 2-bit characters in the given binary string
08, Jan 20
Length of longest consecutive ones by at most one swap in a Binary String
06, Dec 18
Count of Binary strings of length N having atmost M consecutive 1s or 0s alternatively exactly K times
12, May 20
Number of ways to cut a stick of length N into in even length at most K units long pieces
18, Jul 20
Count of binary strings of length N having equal count of 0's and 1's and count of 1's ≥ count of 0's in each prefix substring
25, Jul 20
Find array elements with rightmost set bit at the position of the rightmost set bit in K
09, Feb 21
Find the index at which bit must be set to maximise distance between next set bit
26, Jan 22
Find the number of binary strings of length N with at least 3 consecutive 1s
02, Apr 19
Count number of binary strings without consecutive 1’s : Set 2
03, Apr 20
Find a pair of numbers with set bit count as at most that of N and whose Bitwise XOR is N
27, Aug 21
Inserting M into N such that m starts at bit j and ends at bit i | Set-2
29, Aug 18
1 to n bit numbers with no consecutive 1s in binary representation
03, Sep 17
1 to n bit numbers with no consecutive 1s in binary representation.
27, Jul 17
Count of strings with frequency of each character at most X and length at least Y
26, Nov 21
Maximum length of consecutive 1s or 0s after flipping at most K characters
15, Oct 21
Count of even and odd set bit with array element after XOR with K
30, Mar 20
Count of even and odd set bit Array elements after XOR with K for Q queries
22, May 20
Count of N-bit odd and even integers with K set bits
20, Aug 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
webhead
@webhead
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!