Maximum difference of zeros and ones in binary string

Given a binary string of 0s and 1s. The task is to find the length of the substring which is having a maximum difference between the number of 0s and the number of 1s (number of 0s – number of 1s). In case of all 1s print -1.

Examples: 

Input : S = "11000010001"
Output : 6
From index 2 to index 9, there are 7
0s and 1 1s, so number of 0s - number
of 1s is 6.

Input : S = "1111"
Output : -1

Now, at each index i we need to make decision whether to take it or skip it. So, declare a 2D array of size n x 2, where n is the length of the given binary string, say dp[n][2]. 

dp[i][0] define the maximum value upto 
         index i, when we skip the i-th
         index element.
dp[i][1] define the maximum value upto 
         index i after taking the i-th
         index element.

Therefore, we can derive dp[i][] as:
dp[i][0] = max(dp[i+1][0], dp[i+1][1] + arr[i])
dp[i][1] = max(dp[i+1][1] + arr[i], 0)

For all ones, we check this case explicitly.

C++

// CPP Program to find the length of
// substring with maximum difference of
// zeroes and ones in binary string.
#include <bits/stdc++.h>
#define MAX 100
using namespace std;

// Return true if there all 1s
bool allones(string s, int n)
{
    // Checking each index is 1 or not.
    int co = 0;
    for (int i = 0; i < s.size(); i++)
        co += (s[i] == '1');

    return (co == n);
}

// Find the length of substring with maximum
// difference of zeroes and ones in binary
// string
int findlength(int arr[], string s, int n, int ind, int st,
               int dp[][3])
{
    // If string is over.
    if (ind >= n)
        return 0;

    // If the state is already calculated.
    if (dp[ind][st] != -1)
        return dp[ind][st];

    if (st == 0)
        return dp[ind][st]
               = max(arr[ind]
                         + findlength(arr, s, n, ind + 1, 1,
                                      dp),
                     findlength(arr, s, n, ind + 1, 0, dp));

    else
        return dp[ind][st]
               = max(arr[ind]
                         + findlength(arr, s, n, ind + 1, 1,
                                      dp),
                     0);
}

// Returns length of substring which is
// having maximum difference of number
// of 0s and number of 1s
int maxLen(string s, int n)
{
    // If all 1s return -1.
    if (allones(s, n))
        return -1;

    // Else find the length.
    int arr[MAX] = { 0 };
    for (int i = 0; i < n; i++)
        arr[i] = (s[i] == '0' ? 1 : -1);

    int dp[MAX][3];
    memset(dp, -1, sizeof dp);
    return findlength(arr, s, n, 0, 0, dp);
}

// Driven Program
int main()
{
    string s = "11000010001";
    int n = 11;
    cout << maxLen(s, n) << endl;
    return 0;
}

Java

// Java Program to find the length of
// substring with maximum difference of
// zeroes and ones in binary string.
import java.util.Arrays;

class GFG
{
static final int MAX=100;

// Return true if there all 1s
static boolean allones(String s, int n)
{
    // Checking each index is 0 or not.
    int co = 0;
    for (int i = 0; i < s.length(); i++)
        if(s.charAt(i) == '1')
            co +=1;

    return (co == n);
}

// Find the length of substring with maximum
// difference of zeroes and ones in binary
// string
static int findlength(int arr[], String s, int n,
                     int ind, int st, int dp[][])
{
    // If string is over.
    if (ind >= n)
        return 0;

    // If the state is already calculated.
    if (dp[ind][st] != -1)
        return dp[ind][st];

    if (st == 0)
        return dp[ind][st] = Math.max(arr[ind] +
                             findlength(arr, s, n,
                                   ind + 1, 1, dp),
                             findlength(arr, s, n,
                                   ind + 1, 0, dp));

    else
        return dp[ind][st] = Math.max(arr[ind] +
                             findlength(arr, s, n,
                               ind + 1, 1, dp), 0);
}

// Returns length of substring which is
// having maximum difference of number
// of 0s and number of 1s
static int maxLen(String s, int n)
{
    // If all 1s return -1.
    if (allones(s, n))
        return -1;

    // Else find the length.
    int arr[] = new int[MAX];
    for (int i = 0; i < n; i++)
        arr[i] = (s.charAt(i) == '0' ? 1 : -1);

    int dp[][] = new int[MAX][3];
    for (int[] row : dp)
            Arrays.fill(row, -1);
    return findlength(arr, s, n, 0, 0, dp);
}

// Driver code
public static void main (String[] args)
{
    String s = "11000010001";
    int n = 11;
    System.out.println(maxLen(s, n));
}
}

// This code is contributed by Anant Agarwal.

Python3

# Python Program to find the length of
# substring with maximum difference of
# zeroes and ones in binary string.
MAX = 100

# Return true if there all 1s
def allones(s, n):

    # Checking each index
    # is 0 or not.
    co = 0

    for i in s:
        co += 1 if i == '1' else 0

    return co == n

# Find the length of substring with
# maximum difference of zeroes and
# ones in binary string
def findlength(arr, s, n, ind, st, dp):

    # If string is over
    if ind >= n:
        return 0

    # If the state is already calculated.
    if dp[ind][st] != -1:
        return dp[ind][st]

    if not st:
        dp[ind][st] = max(arr[ind] +
           findlength(arr, s, n, ind + 1, 1, dp),
            (findlength(arr, s, n, ind + 1, 0, dp)))
    else:
        dp[ind][st] = max(arr[ind] +
         findlength(arr, s, n, ind + 1, 1, dp), 0)

    return dp[ind][st]

# Returns length of substring which is
# having maximum difference of number
# of 0s and number of 1s
def maxLen(s, n):

    # If all 1s return -1.
    if allones(s, n):
        return -1

    # Else find the length.
    arr = [0] * MAX
    for i in range(n):
        arr[i] = 1 if s[i] == '0' else -1

    dp = [[-1] * 3 for _ in range(MAX)]
    return findlength(arr, s, n, 0, 0, dp)

# Driven Program
s = "11000010001"
n = 11
print(maxLen(s, n))

# This code is contributed by Ansu Kumari.

C#

// C# Program to find the length of
// substring with maximum difference of
// zeroes and ones in binary string.
using System;

class GFG
{
    static int MAX = 100;

    // Return true if there all 1s
    public static bool allones(string s, int n)
    {
        // Checking each index is 0 or not.
        int co = 0;
        for (int i = 0; i < s.Length; i++)
            co += (s[i] == '1' ? 1 : 0);

        return (co == n);
    }

    // Find the length of substring with maximum
    // difference of zeroes and ones in binary
    // string
    public static int findlength(int[] arr, string s,
                    int n, int ind, int st, int[,] dp)
    {
        // If string is over.
        if (ind >= n)
            return 0;

        // If the state is already calculated.
        if (dp[ind,st] != -1)
            return dp[ind,st];

        if (st == 0)
            return dp[ind,st] = Math.Max(arr[ind] +
            findlength(arr, s, n, ind + 1, 1, dp),
            findlength(arr, s, n, ind + 1, 0, dp));

        else
            return dp[ind,st] = Math.Max(arr[ind] +
        findlength(arr, s, n, ind + 1, 1, dp), 0);
    }

    // Returns length of substring which is
    // having maximum difference of number
    // of 0s and number of 1s
    public static int maxLen(string s, int n)
    {
        // If all 1s return -1.
        if (allones(s, n))
            return -1;

        // Else find the length.
        int[] arr = new int[MAX];

        for (int i = 0; i < n; i++)
            arr[i] = (s[i] == '0' ? 1 : -1);

        int[,] dp = new int[MAX,3];
        for(int i = 0; i < MAX; i++)
            for(int j = 0; j < 3; j++)
                dp[i,j] = -1;

        return findlength(arr, s, n, 0, 0, dp);
    }

    // Driven Program

    static void Main()
    {
        string s = "11000010001";
        int n = 11;
        Console.Write(maxLen(s, n));
    }
    // This code is contributed by DrRoot_
}

Javascript

<script>

// Javascript Program to find the length of
// substring with maximum difference of
// zeroes and ones in binary string.
var MAX = 100;

// Return true if there all 1s
function allones( s,  n)
{
    // Checking each index is 0 or not.
    var co = 0;
    for (var i = 0; i < s.length; i++)
        co += (s[i] == '1');

    return (co == n);
}

// Find the length of substring with maximum
// difference of zeroes and ones in binary
// string
function findlength(arr, s, n, ind, st, dp)
{
    // If string is over.
    if (ind >= n)
        return 0;

    // If the state is already calculated.
    if (dp[ind][st] != -1)
        return dp[ind][st];

    if (st == 0)
        return dp[ind][st] = Math.max(arr[ind] +
          findlength(arr, s, n, ind + 1, 1, dp),
          findlength(arr, s, n, ind + 1, 0, dp));

    else
        return dp[ind][st] = Math.max(arr[ind] +
       findlength(arr, s, n, ind + 1, 1, dp), 0);
}

// Returns length of substring which is
// having maximum difference of number
// of 0s and number of 1s
function maxLen( s,  n)
{
    // If all 1s return -1.
    if (allones(s, n))
        return -1;

    // Else find the length.
    var arr = Array(MAX).fill(0);
    for (var i = 0; i < n; i++)
        arr[i] = (s[i] == '0' ? 1 : -1);

    var dp = Array.from(Array(MAX), ()=> Array(3).fill(-1));
    return findlength(arr, s, n, 0, 0, dp);
}

// Driven Program
var s = "11000010001";
var n = 11;
document.write( maxLen(s, n));


</script>

Output

6

Time Complexity: O(2*len(s)), 
Auxiliary Space: O(len(s))

Efficient approach: Using DP Tabulation method ( Iterative approach )

The approach to solve this problem is same but DP tabulation(bottom-up) method is better then Dp + memoization(top-down) because memoization method needs extra stack space of recursion calls.

Steps to solve this problem :

• Create a DP to store the solution of the subproblems and initialize it with -1.
• Initialize the DP with base cases.
• Now Iterate over subproblems to get the value of current problem form previous computation of subproblems stored in DP
• Return the final solution stored in dp[0][0].

Implementation :

C++

// CPP Program to find the length of
// substring with maximum difference of
// zeroes and ones in binary string.

#include <bits/stdc++.h>
#define MAX 100
using namespace std;

// Returns length of substring which is
// having maximum difference of number
// of 0s and number of 1s
int maxLen(string s, int n)
{

      bool all_zeros = true, all_ones = true;
    for (int i = 0; i < n; i++) {
        if (s[i] == '0') all_ones = false;
        else all_zeros = false;
    }
    if (all_zeros || all_ones) return -1;

    int arr[MAX] = {0};
    for (int i = 0; i < n; i++)
        arr[i] = (s[i] == '0' ? 1 : -1);

    int dp[MAX][3];
    memset(dp, -1, sizeof(dp));

    // Initializing base case values
    dp[n][0] = dp[n][1] = dp[n][2] = 0;

    // Computing DP values from bottom up
    for (int i = n - 1; i >= 0; i--)
    {
        for (int st = 0; st <= 2; st++)
        {
            if (st == 0)
                dp[i][st] = max(arr[i] + dp[i + 1][1], dp[i + 1][0]);
            else if (st == 1)
                dp[i][st] = max(arr[i] + dp[i + 1][1], 0);
            else
                dp[i][st] = max(arr[i] + dp[i + 1][1], dp[i + 1][2]);
        }
    }

    // Returning the maximum length of substring with difference
    // between 0's and 1's equal to the maximum value of dp
    return dp[0][0];
}

// Driver code
int main()
{
    string s = "11000010001";
    int n = s.length();
    cout << maxLen(s, n) << endl;
    return 0;
}

Java

import java.util.Arrays;

public class Main
{

  // Returns length of substring which is
  // having maximum difference of number
  // of 0s and number of 1s
  public static int maxLen(String s, int n)
  {
    boolean all_zeros = true, all_ones = true;
    for (int i = 0; i < n; i++) {
      if (s.charAt(i) == '0')
        all_ones = false;
      else
        all_zeros = false;
    }
    if (all_zeros || all_ones)
      return -1;

    int[] arr = new int[100];
    for (int i = 0; i < n; i++)
      arr[i] = (s.charAt(i) == '0' ? 1 : -1);

    int[][] dp = new int[100][3];
    for (int[] row : dp)
      Arrays.fill(row, -1);

    // Initializing base case values
    dp[n][0] = dp[n][1] = dp[n][2] = 0;

    // Computing DP values from bottom up
    for (int i = n - 1; i >= 0; i--) {
      for (int st = 0; st <= 2; st++) {
        if (st == 0)
          dp[i][st]
          = Math.max(arr[i] + dp[i + 1][1],
                     dp[i + 1][0]);
        else if (st == 1)
          dp[i][st] = Math.max(
          arr[i] + dp[i + 1][1], 0);
        else
          dp[i][st]
          = Math.max(arr[i] + dp[i + 1][1],
                     dp[i + 1][2]);
      }
    }

    // Returning the maximum length of substring with
    // difference between 0's and 1's equal to the
    // maximum value of dp
    return dp[0][0];
  }

  // Driver code
  public static void main(String[] args)
  {
    String s = "11000010001";
    int n = s.length();
    System.out.println(maxLen(s, n));
  }
}

Python

MAX = 100

# Returns length of substring which is
# having maximum difference of number
# of 0s and number of 1s
def maxLen(s, n):
    all_zeros = True
    all_ones = True
    for i in range(n):
        if s[i] == '0':
            all_ones = False
        else:
            all_zeros = False
    if all_zeros or all_ones:
        return -1

    arr = [0] * MAX
    for i in range(n):
        arr[i] = 1 if s[i] == '0' else -1

    dp = [[-1 for _ in range(3)] for _ in range(MAX)]

    # Initializing base case values
    dp[n][0] = dp[n][1] = dp[n][2] = 0

    # Computing DP values from bottom up
    for i in range(n - 1, -1, -1):
        for st in range(3):
            if st == 0:
                dp[i][st] = max(arr[i] + dp[i + 1][1], dp[i + 1][0])
            elif st == 1:
                dp[i][st] = max(arr[i] + dp[i + 1][1], 0)
            else:
                dp[i][st] = max(arr[i] + dp[i + 1][1], dp[i + 1][2])

    # Returning the maximum length of substring with difference
    # between 0's and 1's equal to the maximum value of dp
    return dp[0][0]

# Driver code
if __name__ == '__main__':
    s = "11000010001"
    n = len(s)
    print(maxLen(s, n))

C#

using System;

class GFG {
    // Returns length of substring which is
    // having maximum difference of number
    // of 0s and number of 1s
    static int maxLen(string s, int n)
    {
        // Check if all characters are either 0 or 1
        bool all_zeros = true, all_ones = true;
        for (int i = 0; i < n; i++) {
            if (s[i] == '0')
                all_ones = false;
            else
                all_zeros = false;
        }
        if (all_zeros || all_ones)
            return -1;

        // Convert string to an array of integers
        int[] arr = new int[100];
        for (int i = 0; i < n; i++)
            arr[i] = (s[i] == '0' ? 1 : -1);

        // Initialize DP array with -1
        int[, ] dp = new int[100, 3];
        for (int i = n - 1; i >= 0; i--) {
            for (int st = 0; st <= 2; st++) {
                if (st == 0)
                    dp[i, st]
                        = Math.Max(arr[i] + dp[i + 1, 1],
                                   dp[i + 1, 0]);
                else if (st == 1)
                    dp[i, st] = Math.Max(
                        arr[i] + dp[i + 1, 1], 0);
                else
                    dp[i, st]
                        = Math.Max(arr[i] + dp[i + 1, 1],
                                   dp[i + 1, 2]);
            }
        }

        // Return the maximum length of substring with
        // difference between 0's and 1's equal to the
        // maximum value of dp
        return dp[0, 0];
    }

    // Driver code
    public static void Main()
    {
        string s = "11000010001";
        int n = s.Length;
        Console.WriteLine(maxLen(s, n));
    }
}

Output

6

Time Complexity: O(2*len(s)), 
Auxiliary Space: O(MAX*3) , MAX = 100

Maximum difference of zeros and ones in binary string | Set 2 (O(n) time)