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
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 <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> |
149
Time Complexity: O(N)
Auxiliary Space: O(N)