Maximize number of 0s by flipping a subarray

Given a binary array, find the maximum number of zeros in an array with one flip of a subarray allowed. A flip operation switches all 0s to 1s and 1s to 0s.
Examples:

```Input :  arr[] = {0, 1, 0, 0, 1, 1, 0}
Output : 6
We can get 6 zeros by flipping the subarray {4, 5}

Input :  arr[] = {0, 0, 0, 1, 0, 1}
Output : 5```
Recommended Practice

Method 1 (Simple : O(n2)): A simple solution is to consider all subarrays and find a subarray with maximum value of (count of 1s) – (count of 0s). Let this value be max_diff. Finally, return count of zeros in original array plus max_diff.

C++

 `// C++ program to maximize number of zeroes in a` `// binary array by at most one flip operation` `#include` `using` `namespace` `std;`   `// A Kadane's algorithm based solution to find maximum` `// number of 0s by flipping a subarray.` `int` `findMaxZeroCount(``bool` `arr[], ``int` `n)` `{` `    ``// Initialize max_diff = maximum of (Count of 0s -` `    ``// count of 1s) for all subarrays.` `    ``int` `max_diff = 0;`   `    ``// Initialize count of 0s in original array` `    ``int` `orig_zero_count = 0;`   `    ``// Consider all Subarrays by using two nested two` `    ``// loops` `    ``for` `(``int` `i=0; i

Java

 `// Java code for Maximize number of 0s by flipping ` `// a subarray` `class` `GFG {` `     `  `    ``// A Kadane's algorithm based solution to find maximum` `    ``// number of 0s by flipping a subarray. ` `    ``public` `static` `int` `findMaxZeroCount(``int` `arr[], ``int` `n)` `    ``{` `        ``// Initialize max_diff = maximum of (Count of 0s -` `        ``// count of 1s) for all subarrays.` `        ``int` `max_diff = ``0``;` `     `  `        ``// Initialize count of 0s in original array` `        ``int` `orig_zero_count = ``0``;` `     `  `        ``// Consider all Subarrays by using two nested two` `        ``// loops` `        ``for` `(``int` `i=``0``; i

Python3

 `# Python3 program to maximize number of ` `# zeroes in a binary array by at most ` `# one flip operation`   `# A Kadane's algorithm based solution` `# to find maximum number of 0s by` `# flipping a subarray.` `def` `findMaxZeroCount(arr, n):` `    `  `    ``# Initialize max_diff = maximum ` `    ``# of (Count of 0s - count of 1s)` `    ``# for all subarrays.` `    ``max_diff ``=` `0` `    `  `    ``# Initialize count of 0s in` `    ``# original array` `    ``orig_zero_count ``=` `0` `    `  `    ``# Consider all Subarrays by using` `    ``# two nested two loops ` `    ``for` `i ``in` `range``(n):` `        `  `        ``# Increment count of zeros ` `        ``if` `arr[i] ``=``=` `0``:` `            ``orig_zero_count ``+``=` `1` `        `  `        ``# Initialize counts of 0s and 1s` `        ``count1, count0 ``=` `0``, ``0` `        `  `        ``# Consider all subarrays starting` `        ``# from arr[i] and find the ` `        ``# difference between 1s and 0s. ` `        ``# Update max_diff if required ` `        ``for` `j ``in` `range``(i, n):` `            ``if` `arr[j] ``=``=` `1``:` `                ``count1 ``+``=` `1` `            ``else``: ` `                ``count0 ``+``=` `1` `                `  `            ``max_diff ``=` `max``(max_diff, count1 ``-` `                                     ``count0)` `    `  `    ``# Final result would be count of 0s ` `    ``# in original array plus max_diff. ` `    ``return` `orig_zero_count ``+` `max_diff`   `# Driver code` `arr ``=` `[ ``0``, ``1``, ``0``, ``0``, ``1``, ``1``, ``0` `]` `n ``=` `len``(arr)`   `print``(findMaxZeroCount(arr, n))`   `# This code is contributed by stutipathak31jan`

C#

 `// C# code for Maximize number of 0s by ` `// flipping a subarray` `using` `System;`   `class` `GFG{` `    `  `// A Kadane's algorithm based solution` `// to find maximum number of 0s by` `// flipping a subarray. ` `public` `static` `int` `findMaxZeroCount(``int` `[]arr,` `                                   ``int` `n)` `{` `    `  `    ``// Initialize max_diff = maximum of` `    ``// (Count of 0s - count of 1s) for ` `    ``// all subarrays.` `    ``int` `max_diff = 0;`   `    ``// Initialize count of 0s in ` `    ``// original array` `    ``int` `orig_zero_count = 0;`   `    ``// Consider all Subarrays by` `    ``// using two nested two loops` `    ``for``(``int` `i = 0; i < n; i++)` `    ``{` `        `  `        ``// Increment count of zeros` `        ``if` `(arr[i] == 0)` `            ``orig_zero_count++;`   `        ``// Initialize counts of 0s and 1s` `        ``int` `count1 = 0, count0 = 0;`   `        ``// Consider all subarrays starting` `        ``// from arr[i] and find the difference` `        ``// between 1s and 0s.` `        ``// Update max_diff if required` `        ``for``(``int` `j = i; j < n; j ++)` `        ``{` `            ``if``(arr[j] == 1)` `                ``count1++;` `                `  `            ``else` `count0++;` `            ``max_diff = Math.Max(max_diff, ` `                                ``count1 - count0);` `        ``}` `    ``}`   `    ``// Final result would be count of 0s in original` `    ``// array plus max_diff.` `    ``return` `orig_zero_count + max_diff;` `}`   `// Driver code` `public` `static` `void` `Main(String[] args) ` `{` `    ``int` `[]arr = { 0, 1, 0, 0, 1, 1, 0 };` `    `  `    ``Console.WriteLine(` `        ``findMaxZeroCount(arr, arr.Length));` `}` `}`   `// This code is contributed by amal kumar choubey `

Javascript

 ``

Output

`6`

Time Complexity: O(n2)

Auxiliary Space: O(1)

As constant extra space is used.

Method 2 (Efficient : O(n)): This problem can be reduced to largest subarray sum problem. The idea is to consider every 0 as -1 and every 1 as 1, find the sum of largest subarray sum in this modified array. This sum is our required max_diff ( count of 0s – count of 1s in any subarray). Finally we return the max_diff plus count of zeros in original array.

C++

 `// C++ program to maximize number of zeroes in a` `// binary array by at most one flip operation` `#include` `using` `namespace` `std;`   `// A Kadane's algorithm based solution to find maximum` `// number of 0s by flipping a subarray.` `int` `findMaxZeroCount(``bool` `arr[], ``int` `n)` `{` `    ``// Initialize count of zeros and maximum difference` `    ``// between count of 1s and 0s in a subarray` `    ``int` `orig_zero_count = 0;`   `    ``// Initiale overall max diff for any subarray` `    ``int` `max_diff = 0;`   `    ``// Initialize current diff` `    ``int` `curr_max = 0;`   `    ``for` `(``int` `i=0; i

Java

 `// Java code for Maximize number of 0s by ` `// flipping a subarray` `class` `GFG {` `     `  `    ``// A Kadane's algorithm based solution to find maximum` `    ``// number of 0s by flipping a subarray.` `    ``public` `static` `int` `findMaxZeroCount(``int` `arr[], ``int` `n)` `    ``{` `        ``// Initialize count of zeros and maximum difference` `        ``// between count of 1s and 0s in a subarray` `        ``int` `orig_zero_count = ``0``;` `     `  `        ``// Initiale overall max diff for any subarray` `        ``int` `max_diff = ``0``;` `     `  `        ``// Initialize current diff` `        ``int` `curr_max = ``0``;` `     `  `        ``for` `(``int` `i = ``0``; i < n; i ++)` `        ``{` `            ``// Count of zeros in original array (Not related` `            ``// to Kadane's algorithm)` `            ``if` `(arr[i] == ``0``)` `               ``orig_zero_count ++;` `     `  `            ``// Value to be considered for finding maximum sum` `            ``int` `val = (arr[i] == ``1``)? ``1` `: -``1``;` `     `  `            ``// Update current max and max_diff` `            ``curr_max = Math.max(val, curr_max + val);` `            ``max_diff = Math.max(max_diff, curr_max);` `        ``}` `        ``max_diff = Math.max(``0``, max_diff);` `     `  `        ``return` `orig_zero_count + max_diff;` `    ``}` `    `  `    ``/* Driver program to test above function */` `    ``public` `static` `void` `main(String[] args) ` `    ``{` `        ``int` `arr[] = {``0``, ``1``, ``0``, ``0``, ``1``, ``1``, ``0``};` `        `  `        ``System.out.println(findMaxZeroCount(arr, arr.length));` `    ``}` `  ``}` `// This code is contributed by Arnav Kr. Mandal.`

Python3

 `# Python3 program to maximize number ` `# of zeroes in a binary array by at ` `# most one flip operation`   `# A Kadane's algorithm based solution` `# to find maximum number of 0s by ` `# flipping a subarray.` `def` `findMaxZeroCount(arr, n):` `    `  `    ``# Initialize count of zeros and` `    ``# maximum difference between count` `    ``# of 1s and 0s in a subarray ` `    ``orig_zero_count ``=` `0` `    `  `    ``# Initialize overall max diff` `    ``# for any subarray ` `    ``max_diff ``=` `0` `    `  `    ``# Initialize current diff ` `    ``curr_max ``=` `0` `    `  `    ``for` `i ``in` `range``(n):` `        `  `        ``# Count of zeros in original ` `        ``# array (Not related to ` `        ``# Kadane's algorithm) ` `        ``if` `arr[i] ``=``=` `0``:` `            ``orig_zero_count ``+``=` `1` `        `  `        ``# Value to be considered for` `        ``# finding maximum sum` `        ``val ``=` `1` `if` `arr[i] ``=``=` `1` `else` `-``1` `        `  `        ``# Update current max and max_diff` `        ``curr_max ``=` `max``(val, curr_max ``+` `val)` `        ``max_diff ``=` `max``(max_diff, curr_max)` `        `  `    ``max_diff ``=` `max``(``0``, max_diff)` `    `  `    ``return` `orig_zero_count ``+` `max_diff`   `# Driver code` `arr ``=` `[ ``0``, ``1``, ``0``, ``0``, ``1``, ``1``, ``0` `]` `n ``=` `len``(arr)`   `print``(findMaxZeroCount(arr, n))`   `# This code is contributed by stutipathak31jan`

C#

 `// C# code for Maximize number of 0s by ` `// flipping a subarray` `using` `System;` `class` `GFG{` `     `  `  ``// A Kadane's algorithm based solution to find maximum` `  ``// number of 0s by flipping a subarray.` `  ``public` `static` `int` `findMaxZeroCount(``int` `[]arr, ``int` `n)` `  ``{` `    ``// Initialize count of zeros and maximum difference` `    ``// between count of 1s and 0s in a subarray` `    ``int` `orig_zero_count = 0;`   `    ``// Initiale overall max diff for any subarray` `    ``int` `max_diff = 0;`   `    ``// Initialize current diff` `    ``int` `curr_max = 0;`   `    ``for` `(``int` `i = 0; i < n; i ++)` `    ``{` `      ``// Count of zeros in original array (Not related` `      ``// to Kadane's algorithm)` `      ``if` `(arr[i] == 0)` `        ``orig_zero_count ++;`   `      ``// Value to be considered for finding maximum sum` `      ``int` `val = (arr[i] == 1)? 1 : -1;`   `      ``// Update current max and max_diff` `      ``curr_max = Math.Max(val, curr_max + val);` `      ``max_diff = Math.Max(max_diff, curr_max);` `    ``}` `    ``max_diff = Math.Max(0, max_diff);`   `    ``return` `orig_zero_count + max_diff;` `  ``}`   `  ``// Driver Code` `  ``public` `static` `void` `Main(String[] args) ` `  ``{` `    ``int` `[]arr = {0, 1, 0, 0, 1, 1, 0};`   `    ``Console.WriteLine(findMaxZeroCount(arr, arr.Length));` `  ``}` `}`   `// This code is contributed by Rohit_ranjan`

Javascript

 ``

Output

`6`

Time Complexity: O(n)

Auxiliary Space: O(1)

As constant extra space is used.

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

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next