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 = 4Output:13

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

1000, 0101, 0011, 1010, 1001, 0110, 1100, 1101 and 1011.Input:N = 2Output: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` |

## Javascript

`<script>` `// Javascript implementation of the approach` `var` `MOD = 1000000007;` `// Function to return the count of` `// all possible binary strings` `function` `countStr(N)` `{` ` ` `var` `dp = Array.from(Array(N+1), ()=> Array(3).fill(0));` ` ` `// Base cases` ` ` `dp[1][0] = 1;` ` ` `dp[1][1] = 1;` ` ` `dp[1][2] = 0;` ` ` `for` `(` `var` `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` ` ` `var` `ans = (dp[N][0] + dp[N][1] + dp[N][2]) % MOD;` ` ` `return` `ans;` `}` `// Driver code` `var` `N = 8;` `document.write( countStr(N));` `// This code is contributed by itsok.` `</script>` |

**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. To complete your preparation from learning a language to DS Algo and many more, please refer **Complete Interview Preparation Course****.**

In case you wish to attend live classes with industry experts, please refer **Geeks Classes Live**