# 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:
Explanation:
The possible binary strings are 0000, 0101, 1001, 1010. They all have even number of 1’s with less than 2 of them occuring consecutively.

Input: N = 3, K = 2
Output:
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][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: Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach ` `#include   ` `using` `namespace` `std; ` ` `  `// Table to store solution ` `// of each subproblem ` `int` `dp; ` ` `  `// 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 `

## 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 `

Output:

```2
```

Time Complexity: O(2*N*K) My Personal Notes arrow_drop_up 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.

1

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.