# 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 : 6From index 2 to index 9, there are 70s and 1 1s, so number of 0s - numberof 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 ``#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

 ``

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 ``#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));``    ``}``}`

## Javascript

 `// Javascript implementation of given problem` `MAX = 100` `// Returns length of substring which is``// having maximum difference of number``// of 0s and number of 1s``function` `maxLen(s, n) {``    ``all_zeros = ``true``    ``all_ones = ``true``    ``for` `(i = 0; i < n; i++) {``        ``if` `(s[i] == ``'0'``) {``            ``all_ones = ``false``        ``} ``else` `{``            ``all_zeros = ``false``        ``}``    ``}``    ` `    ``if` `(all_zeros || all_ones) {``        ``return` `-1``    ``}` `    ``var` `arr = ``new` `Array(MAX);``    ``for` `(i = 0; i < n; i++) {``         ``if` `(s[i] == ``'0'``) {``             ``arr[i] = 1;``         ``}``        ``else` `{``            ``arr[i] = -1;``        ``}``    ``}` `    ``var` `dp = ``new` `Array(MAX);``    ``for` `(``var` `i = 0; i < MAX; i++) {``        ``dp[i] = ``new` `Array(3);``        ``for` `(``var` `j = 0; j < 3; j++) {``            ``dp[i][j] = -1;``        ``}``    ``}` `    ``// Initializing base case values``    ``dp[n][0] = dp[n][1] = dp[n][2] = 0` `    ``// Computing DP values from bottom up``    ``for` `(i = n - 1; i >= 0; i--) {``        ``for` `(st = 0; st < 3; 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``s = ``"11000010001"``n = s.length;``console.log(maxLen(s, n))` `// This code is contributed by Tapesh(tapeshdua420)`

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)

Previous
Next