Number of binary strings such that there is no substring of length ≥ 3

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 109 + 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

Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 ith 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)th position so we take that value.
dp[i][2] = dp[i – 1][1] as first 1 appeared at (i – 1)th position (consecutively) so we take that value directly.
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 Nth position.

Below is the implementation of the above approach:

 `// C++ implementation of the approach ` `#include ` `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 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 `

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