Count number of binary strings such that there is no substring of length greater than or equal to 3 with all 1’s

Given an integer N, the task is to count the number of binary strings possible of length N such that they don’t contain “111” as a substring. The answer could be large so print answer modulo 109 + 7.

Examples:

Input: N = 3
Output: 7
All possible substring are “000”, “001”,
“010”, “011”, “100”, “101” and “110”.
“111” is not a valid string.



Input N = 16
Output: 19513

Approach: Dynamic programming can be used to solve this problem. Create a dp[][] array where dp[i][j] will store the count of possible substrings such that 1 appears j times consecutively upto the ith index. Now, the recurrence relations will be:

dp[i][0] = dp[i – 1][0] + dp[i – 1][1] + dp[i – 1][2]
dp[i][1] = dp[i – 1][0]
dp[i][2] = dp[i – 1][1]

And the base cases will be dp[1][0] = 1, dp[1][1] = 1 and dp[1][2] = 0. Now, the required count of strings will be dp[N][0] + dp[N][1] + dp[N][2].

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
  
const long MOD = 1000000007;
  
// Function to return the count
// of all possible valid strings
long countStrings(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] = number of possible strings
        // such that '1' just appeared consecutively
        // j times upto the 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 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 = 3;
  
    cout << countStrings(N);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the approach 
MOD = 1000000007
  
# Function to return the count 
# of all possible valid strings 
def countStrings(N): 
  
    # Initialise and fill 0's in the dp array
    dp = [[0] * 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] = number of possible strings 
        # such that '1' just appeared consecutively 
        # j times upto the 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 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 = 3
  
    print(countStrings(N)) 
  
# This code is contributed by ashutosh450

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the above approach 
using System;         
  
class GFG 
{
    static readonly int MOD = 1000000007; 
      
    // Function to return the count 
    // of all possible valid strings 
    static long countStrings(int N) 
    
        int i, j;
          
        int [,]dp = new int[N + 1, 3]; 
      
        // Fill 0's in the dp array 
        for(i = 0; i < N + 1; i++)
        {
            for(j = 9; j < 3; j ++)
            {
                dp[i, j] = 0;
            }
        }
          
        // Base cases 
        dp[1, 0] = 1; 
        dp[1, 1] = 1; 
        dp[1, 2] = 0; 
      
        for (i = 2; i <= N; i++) 
        
      
            // dp[i,j] = number of possible strings 
            // such that '1' just appeared consecutively 
            // j times upto the 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 possible cases that 
        // can appear at the Nth position 
        int ans = (dp[N, 0] + dp[N, 1] + 
                              dp[N, 2]) % MOD; 
      
        return ans; 
    
      
    // Driver code 
    public static void Main (String[] args)
    
        int N = 3; 
      
        Console.WriteLine(countStrings(N)); 
    
}
  
// This code is contributed by Rajput-Ji

chevron_right


Output:

7


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.