Given an integer **N**, the task is to count the number of binary strings possible such that there is no substring of length ≥ 3 of all 1’s. This count can become very large so print the answer modulo **10 ^{9} + 7**.

**Examples:**

Input:N = 4

Output:13

All possible valid strings are 0000, 0001, 0010, 0100,

1000, 0101, 0011, 1010, 1001, 0110, 1100, 1101 and 1011.

Input:N = 2

Output:4

**Approach:** For every value from **1** to **N**, the only required strings are in which the number of substrings in which ‘1’ appears consecutively for just two times, one time or zero times. This can be calculated from **2** to **N** recursively. Dynamic programming can be used for memoization where **dp[i][j]** will store the number of possible strings such that **1** just appeared consecutively **j** times upto the **i ^{th}** index and

**j**will be

**0, 1, 2, …, i**(may vary from

**1**to

**N**).

**dp[i][0] = dp[i – 1][0] + dp[i – 1][1] + dp[i – 1][2]**as in

**i**position,

**0**will be put.

**dp[i][1] = dp[i – 1][0]**as there is no

**1**at the

**(i – 1)**position so we take that value.

^{th}**dp[i][2] = dp[i – 1][1]**as first

**1**appeared at

**(i – 1)**position (consecutively) so we take that value directly.

^{th}The base cases are for length 1 string i.e.

**dp[1][0] = 1**,

**dp[1][1] = 1**,

**dp[1][2] = 0**. So, find all the value

**dp[N][0] + dp[N][1] + dp[N][2]**ans sum of all possible cases at the

**N**position.

^{th}Below is the implementation of the above approach:

## CPP

`// C++ implementation of the approach ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `const` `long` `MOD = 1000000007; ` ` ` `// Function to return the count of ` `// all possible binary strings ` `long` `countStr(` `long` `N) ` `{ ` ` ` ` ` `long` `dp[N + 1][3]; ` ` ` ` ` `// Fill 0's in the dp array ` ` ` `memset` `(dp, 0, ` `sizeof` `(dp)); ` ` ` ` ` `// Base cases ` ` ` `dp[1][0] = 1; ` ` ` `dp[1][1] = 1; ` ` ` `dp[1][2] = 0; ` ` ` ` ` `for` `(` `int` `i = 2; i <= N; i++) { ` ` ` ` ` `// dp[i][j] is the number of possible ` ` ` `// strings such that '1' just appeared ` ` ` `// consecutively j times upto ith index ` ` ` `dp[i][0] = (dp[i - 1][0] + dp[i - 1][1] ` ` ` `+ dp[i - 1][2]) ` ` ` `% MOD; ` ` ` ` ` `// Taking previously calculated value ` ` ` `dp[i][1] = dp[i - 1][0] % MOD; ` ` ` `dp[i][2] = dp[i - 1][1] % MOD; ` ` ` `} ` ` ` ` ` `// Taking all the possible cases that ` ` ` `// can appear at the Nth position ` ` ` `long` `ans = (dp[N][0] + dp[N][1] + dp[N][2]) % MOD; ` ` ` ` ` `return` `ans; ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` `long` `N = 8; ` ` ` ` ` `cout << countStr(N); ` ` ` ` ` `return` `0; ` `} ` |

## Java

`// Java implementation of the approach ` `class` `GFG ` `{ ` ` ` ` ` `final` `static` `long` `MOD = ` `1000000007` `; ` ` ` ` ` `// Function to return the count of ` ` ` `// all possible binary strings ` ` ` `static` `long` `countStr(` `int` `N) ` ` ` `{ ` ` ` `long` `dp[][] = ` `new` `long` `[N + ` `1` `][` `3` `]; ` ` ` ` ` `// Fill 0's in the dp array ` ` ` `//memset(dp, 0, sizeof(dp)); ` ` ` ` ` `// Base cases ` ` ` `dp[` `1` `][` `0` `] = ` `1` `; ` ` ` `dp[` `1` `][` `1` `] = ` `1` `; ` ` ` `dp[` `1` `][` `2` `] = ` `0` `; ` ` ` ` ` `for` `(` `int` `i = ` `2` `; i <= N; i++) ` ` ` `{ ` ` ` ` ` `// dp[i][j] is the number of possible ` ` ` `// strings such that '1' just appeared ` ` ` `// consecutively j times upto ith index ` ` ` `dp[i][` `0` `] = (dp[i - ` `1` `][` `0` `] + dp[i - ` `1` `][` `1` `] ` ` ` `+ dp[i - ` `1` `][` `2` `]) % MOD; ` ` ` ` ` `// Taking previously calculated value ` ` ` `dp[i][` `1` `] = dp[i - ` `1` `][` `0` `] % MOD; ` ` ` `dp[i][` `2` `] = dp[i - ` `1` `][` `1` `] % MOD; ` ` ` `} ` ` ` ` ` `// Taking all the possible cases that ` ` ` `// can appear at the Nth position ` ` ` `long` `ans = (dp[N][` `0` `] + dp[N][` `1` `] + dp[N][` `2` `]) % MOD; ` ` ` ` ` `return` `ans; ` ` ` `} ` ` ` ` ` `// Driver code ` ` ` `public` `static` `void` `main (String[] args) ` ` ` `{ ` ` ` `int` `N = ` `8` `; ` ` ` ` ` `System.out.println(countStr(N)); ` ` ` `} ` `} ` ` ` `// This code is contributed by AnkitRai01 ` |

## Python

`# Python3 implementation of the approach ` `MOD ` `=` `1000000007` ` ` `# Function to return the count of ` `# all possible binary strings ` `def` `countStr(N): ` ` ` ` ` `dp ` `=` `[[` `0` `for` `i ` `in` `range` `(` `3` `)] ` `for` `i ` `in` `range` `(N ` `+` `1` `)] ` ` ` ` ` `# Base cases ` ` ` `dp[` `1` `][` `0` `] ` `=` `1` ` ` `dp[` `1` `][` `1` `] ` `=` `1` ` ` `dp[` `1` `][` `2` `] ` `=` `0` ` ` ` ` `for` `i ` `in` `range` `(` `2` `, N ` `+` `1` `): ` ` ` ` ` `# dp[i][j] is the number of possible ` ` ` `# strings such that '1' just appeared ` ` ` `# consecutively j times upto ith index ` ` ` `dp[i][` `0` `] ` `=` `(dp[i ` `-` `1` `][` `0` `] ` `+` `dp[i ` `-` `1` `][` `1` `] ` `+` ` ` `dp[i ` `-` `1` `][` `2` `]) ` `%` `MOD ` ` ` ` ` `# Taking previously calculated value ` ` ` `dp[i][` `1` `] ` `=` `dp[i ` `-` `1` `][` `0` `] ` `%` `MOD ` ` ` `dp[i][` `2` `] ` `=` `dp[i ` `-` `1` `][` `1` `] ` `%` `MOD ` ` ` ` ` `# Taking all the possible cases that ` ` ` `# can appear at the Nth position ` ` ` `ans ` `=` `(dp[N][` `0` `] ` `+` `dp[N][` `1` `] ` `+` `dp[N][` `2` `]) ` `%` `MOD ` ` ` ` ` `return` `ans ` ` ` `# Driver code ` `if` `__name__ ` `=` `=` `'__main__'` `: ` ` ` `N ` `=` `8` ` ` ` ` `print` `(countStr(N)) ` ` ` `# This code is contributed by mohit kumar 29 ` |

## C#

`// C# implementation of the approach ` `using` `System; ` ` ` `class` `GFG ` `{ ` ` ` ` ` `static` `long` `MOD = 1000000007; ` ` ` ` ` `// Function to return the count of ` ` ` `// all possible binary strings ` ` ` `static` `long` `countStr(` `int` `N) ` ` ` `{ ` ` ` `long` `[,]dp = ` `new` `long` `[N + 1, 3]; ` ` ` ` ` `// Base cases ` ` ` `dp[1, 0] = 1; ` ` ` `dp[1, 1] = 1; ` ` ` `dp[1, 2] = 0; ` ` ` ` ` `for` `(` `int` `i = 2; i <= N; i++) ` ` ` `{ ` ` ` ` ` `// dp[i,j] is the number of possible ` ` ` `// strings such that '1' just appeared ` ` ` `// consecutively j times upto ith index ` ` ` `dp[i, 0] = (dp[i - 1, 0] + dp[i - 1, 1] ` ` ` `+ dp[i - 1, 2]) % MOD; ` ` ` ` ` `// Taking previously calculated value ` ` ` `dp[i, 1] = dp[i - 1, 0] % MOD; ` ` ` `dp[i, 2] = dp[i - 1, 1] % MOD; ` ` ` `} ` ` ` ` ` `// Taking all the possible cases that ` ` ` `// can appear at the Nth position ` ` ` `long` `ans = (dp[N, 0] + dp[N, 1] + dp[N, 2]) % MOD; ` ` ` ` ` `return` `ans; ` ` ` `} ` ` ` ` ` `// Driver code ` ` ` `public` `static` `void` `Main () ` ` ` `{ ` ` ` `int` `N = 8; ` ` ` ` ` `Console.WriteLine(countStr(N)); ` ` ` `} ` `} ` ` ` `// This code is contributed by AnkitRai01 ` |

**Output:**

149

**Time 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.