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

• Difficulty Level : Medium
• Last Updated : 15 Feb, 2022

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:

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:

## CPP

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

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

 ``

Output:

`149`

Time Complexity: O(N)

Auxiliary Space: O(N)

My Personal Notes arrow_drop_up