Count of Binary Strings of length at most N with set bit count as multiple of K

• Difficulty Level : Hard
• Last Updated : 28 Oct, 2021

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 = 2
Output: 6
Explanation: Binary strings of atmost N length containing consecutive 1’s as a multiple of K are as follows:

1. Length 1: “0”, contains 0 consecutive 1.
2. Length 2: “00”, “11”, contains 0 and 2 consecutive 1’s respectively.
3. Length 3: “000”, “011”, “110”, contains 0 and two different combinations of 2 consecutive 1’s respectively.

So, total number of strings that can be formed is 6.

Input: N = 5, K = 4
Output: 8

Approach: The given problem can be solved with the help of Dynamic Programming using memoization. Follow the below steps to solve the given problem:

• Create a recursive function cntStrings(N, K), which returns the number of strings of N length having the consecutive 1’s as multiples of K. This can be done by assigning 1 to the next K consecutive indices from the current index and recursively calling for the remaining string or assigning 0 to the current index and recursively calling for the remaining string.
• Create an array dp[] which stores the memorized values of the above recursive function.
• Call the function cntStrings(i, K) for all possible values of i in the range [1, N] and store their sum in a variable cnt.
• The value stored in cnt is the required answer.

Below is the implementation of the above approach:

C++

 // C++ program for the above approach#include using namespace std; int dp; // Recursive function to find the count// of valid binary strings of length nint cntString(int n, int k){    // Base Case    if (n == 0) {        return 1;    }     // If current value is already calculated    if (dp[n] != -1) {        return dp[n];    }     // Stores the current answer    int ans = 0;     // Case for element at next k indices as 1    if (n >= k) {        ans += cntString(n - k, k);    }     // Case for element at current index as 0    ans += cntString(n - 1, k);     // Return ans with storing it in dp[]    return dp[n] = ans;} // Function to find the count of valid// binary strings of atmost N lengthint cntStringAll(int N, int K){    // Initializing all elements with -1    memset(dp, -1, sizeof(dp));     // Stores the final answer    int cnt = 0;     // Iterate and calculate the total    // possible binary strings of each    // length in the range [1, N]    for (int i = 1; i <= N; i++) {        cnt += cntString(i, K);    }     // Return Answer    return cnt;} // Driver Codeint main(){    int N = 5;    int K = 4;     cout << cntStringAll(N, K);     return 0;}

Java

 // Java program for the above approachimport java.io.*;class GFG {     static int dp[] = new int;     // Recursive function to find the count    // of valid binary strings of length n    static int cntString(int n, int k)    {        // Base Case        if (n == 0) {            return 1;        }         // If current value is already calculated        if (dp[n] != -1) {            return dp[n];        }         // Stores the current answer        int ans = 0;         // Case for element at next k indices as 1        if (n >= k) {            ans += cntString(n - k, k);        }         // Case for element at current index as 0        ans += cntString(n - 1, k);         // Return ans with storing it in dp[]        return dp[n] = ans;    }     // Function to find the count of valid    // binary strings of atmost N length    static int cntStringAll(int N, int K)    {        // Initializing all elements with -1        for (int i = 0; i < 1001; i++)            dp[i] = -1;         // Stores the final answer        int cnt = 0;         // Iterate and calculate the total        // possible binary strings of each        // length in the range [1, N]        for (int i = 1; i <= N; i++) {            cnt += cntString(i, K);        }         // Return Answer        return cnt;    }     // Driver Code    public static void main(String[] args)    {        int N = 5;        int K = 4;         System.out.println(cntStringAll(N, K));    }} // This code is contributed by dwivediyash

Python3

 # python program for the above approachdp = [-1 for _ in range(1001)] # Recursive function to find the count# of valid binary strings of length ndef cntString(n, k):         # Base Case    if (n == 0):        return 1         # If current value is already calculated    if (dp[n] != -1):        return dp[n]         # Stores the current answer    ans = 0     # Case for element at next k indices as 1    if (n >= k):        ans += cntString(n - k, k)         # Case for element at current index as 0    ans += cntString(n - 1, k)     # Return ans with storing it in dp[]    dp[n] = ans     return dp[n]  # Function to find the count of valid# binary strings of atmost N lengthdef cntStringAll(N, K):         # Stores the final answer    cnt = 0     # Iterate and calculate the total    # possible binary strings of each    # length in the range [1, N]    for i in range(1, N + 1):        cnt += cntString(i, K)     # Return Answer    return cnt # Driver Codeif __name__ == "__main__":     N = 5    K = 4     print(cntStringAll(N, K))     # This code is contributed by rakeshsahni

C#

 // C# program for the above approachusing System; public class GFG{     static int []dp = new int;     // Recursive function to find the count    // of valid binary strings of length n    static int cntString(int n, int k)    {               // Base Case        if (n == 0) {            return 1;        }         // If current value is already calculated        if (dp[n] != -1) {            return dp[n];        }         // Stores the current answer        int ans = 0;         // Case for element at next k indices as 1        if (n >= k) {            ans += cntString(n - k, k);        }         // Case for element at current index as 0        ans += cntString(n - 1, k);         // Return ans with storing it in dp[]        return dp[n] = ans;    }     // Function to find the count of valid    // binary strings of atmost N length    static int cntStringAll(int N, int K)    {               // Initializing all elements with -1        for (int i = 0; i < 1001; i++)            dp[i] = -1;         // Stores the final answer        int cnt = 0;         // Iterate and calculate the total        // possible binary strings of each        // length in the range [1, N]        for (int i = 1; i <= N; i++) {            cnt += cntString(i, K);        }         // Return Answer        return cnt;    }     // Driver Code    public static void Main(String[] args)    {        int N = 5;        int K = 4;         Console.WriteLine(cntStringAll(N, K));    }} // This code is contributed by AnkThon

Javascript


Output
8

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

My Personal Notes arrow_drop_up