Skip to content
Related Articles
Maximize number of 0s by flipping a subarray
• Difficulty Level : Medium
• Last Updated : 25 May, 2021

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 {1, 1}

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

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`

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`

This article is contributed by Shivam Agrawal. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes

My Personal Notes arrow_drop_up