Open in App
Not now

# Count ways to split a Binary String into three substrings having equal count of zeros

• Difficulty Level : Hard
• Last Updated : 14 Jun, 2021

Given binary string str, the task is to count the total number of ways to split the given string into three non-overlapping substrings having the same number of 0s.

Examples:

Input: str = “01010”
Output:
Explanation:
The possible splits are: [0, 10, 10], [01, 01, 0], [01, 0, 10], [0, 101, 0]

Input: str = “11111”
Output: 0

Approach: To solve the problem, the idea is to use the concept of Hashing. Below are the steps to solve the problem:

1. Iterate over the string and count the total number of zeros and store it in a variable, say total_count.
2. Use a Hashmap, say map, to store the frequency of cumulative sum of 0s.
3. Initialize a variable k with total_count/3 which denotes the number of 0 required in each partition.
4. Initialize variables res and sum to store the number of ways to split the string and cumulative sum of 0s respectively.
5. Iterate over the given string and increment sum, if the current character is 0.
6. Increment res by map[k], if sum = 2k and k exist on the map.
7. Update the frequency of the sum in the map.
8. Return res at the end.
9. Return 0, if total_count is not divisible by 3.

Below is the implementation of the above approach:

## C++

 // C++ implementation for the above approach #include using namespace std;   // Function to return ways to split // a string into three  parts // with the equal number of 0 int count(string s) {           // Store total count of 0s     int cnt = 0;       // Count total no. of 0s     // character in given string     for(char c : s)     {         cnt += c == '0' ? 1 : 0;     }       // If total count of 0     // character is not     // divisible by 3     if (cnt % 3 != 0)         return 0;       int res = 0, k = cnt / 3, sum = 0;       // Initialize mp to store     // frequency of k     map mp;       // Traverse string to find     // ways to split string     for(int i = 0; i < s.length(); i++)     {                   // Increment count if 0 appears         sum += s[i] == '0' ? 1 : 0;           // Increment result if sum equal to         // 2*k and k exists in mp         if (sum == 2 * k && mp.find(k) != mp.end() &&             i < s.length() - 1 && i > 0)         {             res += mp[k];         }                   // Insert sum in mp         mp[sum]++;     }           // Return result     return res; }   // Driver Code int main() {           // Given string     string str = "01010";        // Function call     cout << count(str); }   // This code is contributed by rutvik_56

## Java

 // Java implementation for the above approach   import java.util.*; import java.lang.*;   class GFG {       // Function to return ways to split     // a string into three  parts     // with the equal number of 0     static int count(String s)     {         // Store total count of 0s         int cnt = 0;           // Count total no. of 0s         // character in given string         for (char c : s.toCharArray()) {             cnt += c == '0' ? 1 : 0;         }           // If total count of 0         // character is not         // divisible by 3         if (cnt % 3 != 0)             return 0;           int res = 0, k = cnt / 3, sum = 0;           // Initialize map to store         // frequency of k         Map map = new HashMap<>();           // Traverse string to find         // ways to split string         for (int i = 0; i < s.length(); i++) {               // Increment count if 0 appears             sum += s.charAt(i) == '0' ? 1 : 0;               // Increment result if sum equal to             // 2*k and k exists in map             if (sum == 2 * k && map.containsKey(k)                 && i < s.length() - 1 && i > 0) {                 res += map.get(k);             }               // Insert sum in map             map.put(sum,                     map.getOrDefault(sum, 0) + 1);         }           // Return result         return res;     }     // Driver Code     public static void main(String[] args)     {         // Given string         String str = "01010";           // Function call         System.out.println(count(str));     } }

## Python3

 # Python3 implementation for # the above approach   # Function to return ways to split # a string into three  parts # with the equal number of 0 def count(s):       # Store total count of 0s     cnt = 0       # Count total no. of 0s     # character in given string     for c in s:         if c == '0':             cnt += 1       # If total count of 0     # character is not     # divisible by 3     if (cnt % 3 != 0):         return 0       res = 0     k = cnt // 3     sum = 0       # Initialize map to store     # frequency of k     mp = {}       # Traverse string to find     # ways to split string     for i in range(len(s)):           # Increment count if 0 appears         if s[i] == '0':             sum += 1           # Increment result if sum equal to         # 2*k and k exists in map         if (sum == 2 * k and k in mp and             i < len(s) - 1 and i > 0):             res += mp[k]           # Insert sum in map         if sum in mp:             mp[sum] += 1         else:             mp[sum] = 1                   # Return result     return res   # Driver Code if __name__ == "__main__":       # Given string     st = "01010"       # Function call     print(count(st))       # This code is contributed by Chitranayal

## C#

 // C# implementation for the above approach using System; using System.Collections.Generic;   class GFG{   // Function to return ways to split // a string into three parts // with the equal number of 0 static int count(String s) {           // Store total count of 0s     int cnt = 0;       // Count total no. of 0s     // character in given string     foreach(char c in s.ToCharArray())     {         cnt += c == '0' ? 1 : 0;     }       // If total count of 0     // character is not     // divisible by 3     if (cnt % 3 != 0)         return 0;       int res = 0, k = cnt / 3, sum = 0;       // Initialize map to store     // frequency of k     Dictionary map = new Dictionary();       // Traverse string to find     // ways to split string     for(int i = 0; i < s.Length; i++)     {                   // Increment count if 0 appears         sum += s[i] == '0' ? 1 : 0;           // Increment result if sum equal to         // 2*k and k exists in map         if (sum == 2 * k && map.ContainsKey(k) &&             i < s.Length - 1 && i > 0)         {             res += map[k];         }           // Insert sum in map         if(map.ContainsKey(sum))             map[sum] = map[sum] + 1;         else             map.Add(sum, 1);     }       // Return result     return res; }   // Driver Code public static void Main(String[] args) {           // Given string     String str = "01010";       // Function call     Console.WriteLine(count(str)); } }   // This code is contributed by Amit Katiyar

## Javascript



Output

4

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

EFFICIENT APPROACH:

In order to split the input string into three parts, only two cuts are needed, which will give three substrings-S1, S2, and S3. Each substring will have an equal number of 0’s and that will be (total number of 0’s)/3. Now keep track of the count of the number of 0’s from the beginning of the string. Once the count is equal to (total number of 0’s)/3, make the first cut. Similarly, make the second cut once the count of 0’s equals 2*(total number of 1’s)/3.

Algorithm

1. Count the number of 0’s. If not divisible by 3, then answer=0.
2. If the count is 0 then each substring will have an equal number of ‘0’s i.e. zero number of ‘0’s. Therefore, the total number of ways to split the given string is the number of combinations of selecting 2 places to split the string out of n-1 places. For the first selection, we have n-1 choices and for the second selection, we have n-2 choices. Hence, the total number of combinations is (n-1)*(n-2). Since the selections are identical, therefore divide it by factorial of 2. So answer= ((n-1)*(n-2))/2.
3. Traverse the given string from the beginning and keeping count of the number of ‘0s’ again, if the count reaches the (total number of ‘0s’)/3, we begin to accumulate the number of the ways of the 1st cut; when the count reaches the 2*(total number of ‘0s’)/3, we start to accumulate the number of the ways of the 2nd cut.
4. The answer is the multiplication of the number of ways of the 1st cut and 2nd cut.

Below is the implementation of the above approach:

## C++

 // C++ program for above approach #include using namespace std;   // Function to calculate // the number of ways to split int splitstring(string s) {     int n = s.length();       // Calculating the total     // number of zeros     int zeros = 0;     for (int i = 0; i < n; i++)         if (s[i] == '0')             zeros++;       // Case1     // If total count of zeros is not     // divisible by 3     if (zeros % 3 != 0)         return 0;       // Case2     // if total count of zeros     // is zero     if (zeros == 0)         return ((n - 1) * (n - 2)) / 2;       // Case3     // General case       // Number of zeros in each substring     int zerosInEachSubstring = zeros / 3;       // Initialising zero to the number of ways     // for first and second cut     int waysOfFirstCut = 0, waysOfSecondCut = 0;       // Initializing the count     int count = 0;       // Traversing from the beginning     for (int i = 0; i < n; i++)     {                   // Incrementing the count         // if the element is '0'         if (s[i] == '0')             count++;           // Incrementing the ways for the         // 1st cut if count is equal to         // zeros required in each substring         if (count == zerosInEachSubstring)             waysOfFirstCut++;           // Incrementing the ways for the         // 2nd cut if count is equal to         // 2*(zeros required in each substring)         else if (count == 2 * zerosInEachSubstring)             waysOfSecondCut++;     }       // Total number of ways to split is     // multiplication of ways for the 1st     // and 2nd cut     return waysOfFirstCut * waysOfSecondCut; }   // Driver Code int main() {     string s = "01010";         // Function Call     cout << "The number of ways to split is "          << splitstring(s) << endl; }   // this code is contributed by Arif

## Java

 // Java program for above approach import java.util.*;   class GFG{       // Function to calculate // the number of ways to split static int splitstring(String s) {     int n = s.length();       // Calculating the total     // number of zeros     int zeros = 0;     for(int i = 0; i < n; i++)         if (s.charAt(i) == '0')             zeros++;       // Case1     // If total count of zeros is not     // divisible by 3     if (zeros % 3 != 0)         return 0;       // Case2     // if total count of zeros     // is zero     if (zeros == 0)         return ((n - 1) * (n - 2)) / 2;       // Case3     // General case       // Number of zeros in each substring     int zerosInEachSubstring = zeros / 3;       // Initialising zero to the number of ways     // for first and second cut     int waysOfFirstCut = 0;     int waysOfSecondCut = 0;       // Initializing the count     int count = 0;       // Traversing from the beginning     for(int i = 0; i < n; i++)     {                   // Incrementing the count         // if the element is '0'         if (s.charAt(i) == '0')             count++;           // Incrementing the ways for the         // 1st cut if count is equal to         // zeros required in each substring         if (count == zerosInEachSubstring)             waysOfFirstCut++;           // Incrementing the ways for the         // 2nd cut if count is equal to         // 2*(zeros required in each substring)         else if (count == 2 * zerosInEachSubstring)             waysOfSecondCut++;     }       // Total number of ways to split is     // multiplication of ways for the 1st     // and 2nd cut     return waysOfFirstCut * waysOfSecondCut; }   // Driver Code public static void main(String args[]) {     String s = "01010";       // Function Call     System.out.println("The number of " +                        "ways to split is " +                        splitstring(s)); } }   // This code is contributed by Stream_Cipher

## Python3

 # Python3 program for above approach   # Function to calculate # the number of ways to split def splitstring(s):       n = len(s)       # Calculating the total     # number of zeros     zeros = 0     for i in range(n):         if s[i] == '0':             zeros += 1       # Case1     # If total count of zeros is not     # divisible by 3     if zeros % 3 != 0:         return 0       # Case2     # if total count of zeros     # is zero     if zeros == 0:         return ((n - 1) *                 (n - 2)) // 2       # Case3     # General case       # Number of zeros in each substring     zerosInEachSubstring = zeros // 3       # Initialising zero to the number of ways     # for first and second cut     waysOfFirstCut, waysOfSecondCut = 0, 0       # Initializing the count     count = 0       # Traversing from the beginning     for i in range(n):                   # Incrementing the count         # if the element is '0'         if s[i] == '0':             count += 1           # Incrementing the ways for the         # 1st cut if count is equal to         # zeros required in each substring         if (count == zerosInEachSubstring):             waysOfFirstCut += 1           # Incrementing the ways for the         # 2nd cut if count is equal to         # 2*(zeros required in each substring)         elif (count == 2 * zerosInEachSubstring):             waysOfSecondCut += 1       # Total number of ways to split is     # multiplication of ways for the 1st     # and 2nd cut     return waysOfFirstCut * waysOfSecondCut   # Driver code s = "01010"   # Function call print("The number of ways to split is", splitstring(s))   # This code is contributed by divyeshrabadiya07

## C#

 // C# program for above approach using System.Collections.Generic; using System;   class GFG{       // Function to calculate // the number of ways to split static int splitstring(string s) {     int n = s.Length;       // Calculating the total     // number of zeros     int zeros = 0;     for(int i = 0; i < n; i++)         if (s[i] == '0')             zeros++;       // Case1     // If total count of zeros is not     // divisible by 3     if (zeros % 3 != 0)         return 0;       // Case2     // if total count of zeros     // is zero     if (zeros == 0)         return ((n - 1) * (n - 2)) / 2;       // Case3     // General case       // Number of zeros in each substring     int zerosInEachSubstring = zeros / 3;       // Initialising zero to the number of ways     // for first and second cut     int waysOfFirstCut = 0;     int waysOfSecondCut = 0;       // Initializing the count     int count = 0;       // Traversing from the beginning     for(int i = 0; i < n; i++)     {                   // Incrementing the count         // if the element is '0'         if (s[i] == '0')             count++;           // Incrementing the ways for the         // 1st cut if count is equal to         // zeros required in each substring         if (count == zerosInEachSubstring)             waysOfFirstCut++;           // Incrementing the ways for the         // 2nd cut if count is equal to         // 2*(zeros required in each substring)         else if (count == 2 * zerosInEachSubstring)             waysOfSecondCut++;     }       // Total number of ways to split is     // multiplication of ways for the 1st     // and 2nd cut     return waysOfFirstCut * waysOfSecondCut; }   // Driver Code public static void Main() {     string s = "01010";       // Function call     Console.WriteLine("The number of ways " +                       "to split is " +                       splitstring(s)); } }   // This code is contributed by Stream_Cipher

## Javascript



Output

The number of ways to split is 4

Time Complexity: O(n)

Space Complexity: O(1)

My Personal Notes arrow_drop_up
Related Articles