Count possible binary strings of length N without P consecutive 0s and Q consecutive 1s

Given three integers N, P, and Q, the task is to count all possible distinct binary strings of length N such that each binary string does not contain P times consecutive 0’s and Q times consecutive 1’s.

Examples:

Input: N = 5, P = 2, Q = 3
Output: 7
Explanation: Binary strings that satisfy the given conditions are { “01010”, “01011”, “01101”, “10101”, “10110”, “11010”, “11011”}. Therefore, the required output is 7.

Input: N = 5, P = 3, Q = 4
Output: 21

 

Naive Approach: The problem can be solved using Recursion. Following are the recurrence relations and their base cases :



At each possible index of a Binary String, either place the value ‘0‘ or place the value ‘1

Therefore, cntBinStr(str, N, P, Q) = cntBinStr(str + ‘0’, N, P, Q) + cntBinStr(str + ‘1’, N, P, Q)
where cntBinStr(str, N, P, Q) stores the count of distinct binary strings which does not contain P consecutive 1s and Q consecutive 0s.

Base Case: If length(str) == N, check if str satisfy the given condition or not. If found to be true, return 1. Otherwise, return 0.

Below is the implementation of the above approach:

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to implement
// the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if a
// string satisfy the given
// condition or not
bool checkStr(string str,
              int P, int Q)
{
    // Stores the length
    // of string
    int N = str.size();
 
    // Stores the previous
    // character of the string
    char prev = str[0];
 
    // Stores the count of
    // consecutive equal characters
    int cnt = 0;
 
    // Traverse the string
    for (int i = 0; i < N;
         i++) {
 
        // If current character
        // is equal to the
        // previous character
        if (str[i] == prev) {
 
            cnt++;
        }
        else {
 
            // If count of consecutive
            // 1s is more than Q
            if (prev == '1' && cnt >= Q) {
 
                return false;
            }
 
            // If count of consecutive
            // 0s is more than P
            if (prev == '0' && cnt >= P) {
 
                return false;
            }
 
            // Reset value of cnt
            cnt = 1;
        }
 
        prev = str[i];
    }
 
    // If count of consecutive
    // 1s is more than Q
    if (prev == '1' && cnt >= Q) {
        return false;
    }
 
    // If count of consecutive
    // 0s is more than P
    if (prev == '0' && cnt >= P) {
        return false;
    }
 
    return true;
}
 
// Function to count all distinct
// binary strings that satisfy
// the given condition
int cntBinStr(string str, int N,
              int P, int Q)
{
    // Stores the length of str
    int len = str.size();
 
    // If length of str is N
    if (len == N) {
 
        // If str satisfy
        // the given condition
        if (checkStr(str, P, Q))
            return 1;
 
        // If str does not satisfy
        // the given condition
        return 0;
    }
 
    // Append a character '0' at
    // end of str
    int X = cntBinStr(str + '0',
                      N, P, Q);
 
    // Append a character '1' at
    // end of str
    int Y = cntBinStr(str + '1',
                      N, P, Q);
 
    // Return total count
    // of binary strings
    return X + Y;
}
 
// Driver Code
int main()
{
    int N = 5, P = 2, Q = 3;
    cout << cntBinStr("", N, P, Q);
 
    return 0;
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to implement
// the above approach 
class GFG{
   
// Function to check if a
// string satisfy the given
// condition or not
static boolean checkStr(String str,
                        int P, int Q)
{
     
    // Stores the length
    // of string
    int N = str.length();
   
    // Stores the previous
    // character of the string
    char prev = str.charAt(0);
   
    // Stores the count of
    // consecutive equal characters
    int cnt = 0;
   
    // Traverse the string
    for(int i = 0; i < N; i++)
    {
          
        // If current character
        // is equal to the
        // previous character
        if (str.charAt(i) == prev)
        {
            cnt++;
        }
        else
        {
              
            // If count of consecutive
            // 1s is more than Q
            if (prev == '1' && cnt >= Q)
            {
                return false;
            }
   
            // If count of consecutive
            // 0s is more than P
            if (prev == '0' && cnt >= P)
            {
                return false;
            }
   
            // Reset value of cnt
            cnt = 1;
        }
        prev = str.charAt(i);
    }
   
    // If count of consecutive
    // 1s is more than Q
    if (prev == '1' && cnt >= Q)
    {
        return false;
    }
   
    // If count of consecutive
    // 0s is more than P
    if (prev == '0' && cnt >= P)
    {
        return false;
    }
    return true;
}
   
// Function to count all distinct
// binary strings that satisfy
// the given condition
static int cntBinStr(String str, int N,
                          int P, int Q)
{
     
    // Stores the length of str
    int len = str.length();
   
    // If length of str is N
    if (len == N)
    {
          
        // If str satisfy
        // the given condition
        if (checkStr(str, P, Q))
            return 1;
   
        // If str does not satisfy
        // the given condition
        return 0;
    }
   
    // Append a character '0' at
    // end of str
    int X = cntBinStr(str + '0',
                      N, P, Q);
   
    // Append a character '1' at
    // end of str
    int Y = cntBinStr(str + '1',
                      N, P, Q);
   
    // Return total count
    // of binary strings
    return X + Y;
}
   
// Driver Code
public static void main (String[] args)
{
    int N = 5, P = 2, Q = 3;
      
    System.out.println(cntBinStr("", N, P, Q));
}
}
 
// This code is contributed by code_hunt
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to implement
# the above approach
 
# Function to check if a
# satisfy the given
# condition or not
def checkStr(str, P, Q):
     
    # Stores the lenngth
    # of string
    N = len(str)
 
    # Stores the previous
    # character of the string
    prev = str[0]
 
    # Stores the count of
    # consecutive equal
    # characters
    cnt = 0
 
    # Traverse the string
    for i in range(N):
         
        # If current character
        # is equal to the
        # previous character
        if (str[i] == prev):
            cnt += 1
 
        else:
             
            # If count of consecutive
            # 1s is more than Q
            if (prev == '1' and
                cnt >= Q):
                return False
 
            # If count of consecutive
            # 0s is more than P
            if (prev == '0' and
                cnt >= P):
                return False
 
            # Reset value of cnt
            cnt = 1
 
        prev = str[i]
 
    # If count of consecutive
    # 1s is more than Q
    if (prev == '1'and
        cnt >= Q):
        return False
 
    # If count of consecutive
    # 0s is more than P
    if (prev == '0' and
        cnt >= P):
        return False
 
    return True
 
# Function to count all
# distinct binary strings
# that satisfy the given
# condition
def cntBinStr(str, N,
              P, Q):
     
    # Stores the length
    # of str
    lenn = len(str)
 
    # If lenngth of str
    # is N
    if (lenn == N):
 
        # If str satisfy
        # the given condition
        if (checkStr(str, P, Q)):
            return 1
 
        # If str does not satisfy
        # the given condition
        return 0
 
    # Append a character '0'
    # at end of str
    X = cntBinStr(str + '0',
                  N, P, Q)
 
    # Append a character
    # '1' at end of str
    Y = cntBinStr(str + '1',
                  N, P, Q)
 
    # Return total count
    # of binary strings
    return X + Y
 
# Driver Code
if __name__ == '__main__':
     
    N = 5
    P = 2
    Q = 3   
    print(cntBinStr("", N,
                    P, Q))
 
# This code is contributed by mohit kumar 29
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to implement
// the above approach 
using System;
 
class GFG{
  
// Function to check if a
// string satisfy the given
// condition or not
static bool checkStr(string str,
                     int P, int Q)
{
     
    // Stores the length
    // of string
    int N = str.Length;
  
    // Stores the previous
    // character of the string
    char prev = str[0];
  
    // Stores the count of
    // consecutive equal characters
    int cnt = 0;
  
    // Traverse the string
    for(int i = 0; i < N; i++)
    {
         
        // If current character
        // is equal to the
        // previous character
        if (str[i] == prev)
        {
            cnt++;
        }
        else
        {
             
            // If count of consecutive
            // 1s is more than Q
            if (prev == '1' && cnt >= Q)
            {
                return false;
            }
  
            // If count of consecutive
            // 0s is more than P
            if (prev == '0' && cnt >= P)
            {
                return false;
            }
  
            // Reset value of cnt
            cnt = 1;
        }
  
        prev = str[i];
    }
  
    // If count of consecutive
    // 1s is more than Q
    if (prev == '1' && cnt >= Q)
    {
        return false;
    }
  
    // If count of consecutive
    // 0s is more than P
    if (prev == '0' && cnt >= P)
    {
        return false;
    }
     
    return true;
}
  
// Function to count all distinct
// binary strings that satisfy
// the given condition
static int cntBinStr(string str, int N,
                          int P, int Q)
{
     
    // Stores the length of str
    int len = str.Length;
  
    // If length of str is N
    if (len == N)
    {
         
        // If str satisfy
        // the given condition
        if (checkStr(str, P, Q))
            return 1;
  
        // If str does not satisfy
        // the given condition
        return 0;
    }
  
    // Append a character '0' at
    // end of str
    int X = cntBinStr(str + '0',
                      N, P, Q);
  
    // Append a character '1' at
    // end of str
    int Y = cntBinStr(str + '1',
                      N, P, Q);
  
    // Return total count
    // of binary strings
    return X + Y;
}
  
// Driver Code
public static void Main ()
{
    int N = 5, P = 2, Q = 3;
     
    Console.WriteLine(cntBinStr("", N, P, Q));
}
}
 
// This code is contributed by sanjoy_62
chevron_right

Output
7

Time Complexity: O(2N)
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach the idea is to use Dynamic Programming. Follow the steps below to solve the problem:

Insert 0 at the ith index. 
Case 1: If (i – 1)th index of string contains 1. 
 



Case 2: If (i – 1)th index of string contains 0.

for all r in the range [2, P – 1]. 

Insert 1 at the ith index. 
Case 1: If (i-1)th index of string contains 0. 
 

Case 2: If (i-1)th index of string contains 1.

for all j in the range [2, Q – 1]. 

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to implement
// the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to count binary strings
// that satisfy the given condition
int cntBinStr(int N, int P, int Q)
{
    // zero[i][j] stores count
    // of binary strings of length i
    // having j consecutive 0s
    int zero[N + 1][P];
 
    // one[i][j] stores count
    // of binary strings of length i
    // having j consecutive 1s
    int one[N + 1][Q];
 
    // Set all values of
    // zero[][] array to 0
    memset(zero, 0, sizeof(zero));
 
    // Set all values of
    // one[i][j] array to 0
    memset(one, 0, sizeof(one));
 
    // Base case
    zero[1][1] = one[1][1] = 1;
 
    // Fill all the values of zero[i][j]
    // and one[i][j] in bottom up manner
    for (int i = 2; i <= N; i++) {
 
        for (int j = 2; j < P;
             j++) {
            zero[i][j] = zero[i - 1][j - 1];
        }
 
        for (int j = 1; j < Q;
             j++) {
            zero[i][1] = zero[i][1] + one[i - 1][j];
        }
 
        for (int j = 2; j < Q;
             j++) {
            one[i][j] = one[i - 1][j - 1];
        }
 
        for (int j = 1; j < P;
             j++) {
            one[i][1] = one[i][1] + zero[i - 1][j];
        }
    }
 
    // Stores count of binary strings
    // that satisfy the given condition
    int res = 0;
 
    // Count binary strings of
    // length N having less than
    // P consecutive 0s
    for (int i = 1; i < P; i++) {
        res = res + zero[N][i];
    }
 
    // Count binary strings of
    // length N having less than
    // Q consecutive 1s
    for (int i = 1; i < Q; i++) {
        res = res + one[N][i];
    }
 
    return res;
}
 
// Driver Code
int main()
{
    int N = 5, P = 2, Q = 3;
    cout << cntBinStr(N, P, Q);
    return 0;
}
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to implement
// the above approach
import java.util.*;
 
class GFG{
 
// Function to count binary Strings
// that satisfy the given condition
static int cntBinStr(int N, int P, int Q)
{
     
    // zero[i][j] stores count
    // of binary Strings of length i
    // having j consecutive 0s
    int [][]zero = new int[N + 1][P];
 
    // one[i][j] stores count
    // of binary Strings of length i
    // having j consecutive 1s
    int [][]one = new int[N + 1][Q];
 
    // Base case
    zero[1][1] = one[1][1] = 1;
 
    // Fill all the values of zero[i][j]
    // and one[i][j] in bottom up manner
    for(int i = 2; i <= N; i++)
    {
        for(int j = 2; j < P; j++)
        {
            zero[i][j] = zero[i - 1][j - 1];
        }
 
        for(int j = 1; j < Q; j++)
        {
            zero[i][1] = zero[i][1] +
                          one[i - 1][j];
        }
 
        for(int j = 2; j < Q; j++)
        {
            one[i][j] = one[i - 1][j - 1];
        }
 
        for(int j = 1; j < P; j++)
        {
            one[i][1] = one[i][1] +
                       zero[i - 1][j];
        }
    }
 
    // Stores count of binary Strings
    // that satisfy the given condition
    int res = 0;
 
    // Count binary Strings of
    // length N having less than
    // P consecutive 0s
    for(int i = 1; i < P; i++)
    {
        res = res + zero[N][i];
    }
 
    // Count binary Strings of
    // length N having less than
    // Q consecutive 1s
    for(int i = 1; i < Q; i++)
    {
        res = res + one[N][i];
    }
    return res;
}
 
// Driver Code
public static void main(String[] args)
{
    int N = 5, P = 2, Q = 3;
     
    System.out.print(cntBinStr(N, P, Q));
}
}
 
// This code is contributed by Amit Katiyar
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to implement
# the above approach
 
# Function to count binary
# Strings that satisfy the
# given condition
def cntBinStr(N, P, Q):
   
    # zero[i][j] stores count
    # of binary Strings of length i
    # having j consecutive 0s
    zero = [[0 for i in range(P)]
               for j in range(N + 1)];
 
    # one[i][j] stores count
    # of binary Strings of length i
    # having j consecutive 1s
    one = [[0 for i in range(Q)]
              for j in range(N + 1)];
 
    # Base case
    zero[1][1] = one[1][1] = 1;
 
    # Fill all the values of
    # zero[i][j] and one[i][j]
    # in bottom up manner
    for i in range(2, N + 1):
        for j in range(2, P):
            zero[i][j] = zero[i - 1][j - 1];
 
        for j in range(1, Q):
            zero[i][1] = (zero[i][1] +
                          one[i - 1][j]);
 
        for j in range(2, Q):
            one[i][j] = one[i - 1][j - 1];
 
        for j in range(1, P):
            one[i][1] = one[i][1] + zero[i - 1][j];
 
    # Stores count of binary
    # Strings that satisfy
    # the given condition
    res = 0;
 
    # Count binary Strings of
    # length N having less than
    # P consecutive 0s
    for i in range(1, P):
        res = res + zero[N][i];
 
    # Count binary Strings of
    # length N having less than
    # Q consecutive 1s
    for i in range(1, Q):
        res = res + one[N][i];
 
    return res;
 
# Driver Code
if __name__ == '__main__':
   
    N = 5;
    P = 2;
    Q = 3;
    print(cntBinStr(N, P, Q));
 
# This code is contributed by gauravrajput1
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to implement
// the above approach
using System;
 
class GFG{
 
// Function to count binary Strings
// that satisfy the given condition
static int cntBinStr(int N, int P, int Q)
{
     
    // zero[i,j] stores count
    // of binary Strings of length i
    // having j consecutive 0s
    int [,]zero = new int[N + 1, P];
 
    // one[i,j] stores count
    // of binary Strings of length i
    // having j consecutive 1s
    int [,]one = new int[N + 1, Q];
 
    // Base case
    zero[1, 1] = one[1, 1] = 1;
 
    // Fill all the values of zero[i,j]
    // and one[i,j] in bottom up manner
    for(int i = 2; i <= N; i++)
    {
        for(int j = 2; j < P; j++)
        {
            zero[i, j] = zero[i - 1, j - 1];
        }
 
        for(int j = 1; j < Q; j++)
        {
            zero[i, 1] = zero[i, 1] +
                          one[i - 1, j];
        }
 
        for(int j = 2; j < Q; j++)
        {
            one[i, j] = one[i - 1, j - 1];
        }
 
        for(int j = 1; j < P; j++)
        {
            one[i, 1] = one[i, 1] +
                       zero[i - 1, j];
        }
    }
 
    // Stores count of binary Strings
    // that satisfy the given condition
    int res = 0;
 
    // Count binary Strings of
    // length N having less than
    // P consecutive 0s
    for(int i = 1; i < P; i++)
    {
        res = res + zero[N, i];
    }
 
    // Count binary Strings of
    // length N having less than
    // Q consecutive 1s
    for(int i = 1; i < Q; i++)
    {
        res = res + one[N, i];
    }
    return res;
}
 
// Driver Code
public static void Main(String[] args)
{
    int N = 5, P = 2, Q = 3;
     
    Console.Write(cntBinStr(N, P, Q));
}
}
 
// This code is contributed by gauravrajput1
chevron_right

Output
7

Time complexity: O(N * (P + Q))
Auxiliary Space: O(N * (P + Q))

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.




Recommended Posts:


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.



Article Tags :