Maximize number of 0s by flipping a subarray - GeeksforGeeks

29 Aug, 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 {4, 5}

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++
Java
Python3
C#
Javascript
// C++ program to maximize number of zeroes in a// binary array by at most one flip operation#include<bits/stdc++.h>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<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++)        {            (arr[j] == 1)? count1++ : count0++;            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 programint main(){    bool arr[] = {0, 1, 0, 0, 1, 1, 0};    int n = sizeof(arr)/sizeof(arr[0]);    cout << findMaxZeroCount(arr, n);    return 0;}
// Java code for Maximize number of 0s by flipping// a subarrayclass 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 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 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 codearr = [ 0, 1, 0, 0, 1, 1, 0 ]n = len(arr) print(findMaxZeroCount(arr, n)) # This code is contributed by stutipathak31jan
// C# code for Maximize number of 0s by// flipping a subarrayusing 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 codepublic 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
<script> // JavaScript 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.function findMaxZeroCount(arr, n){    // Initialize max_diff = maximum of (Count of 0s -    // count of 1s) for all subarrays.    let max_diff = 0;     // Initialize count of 0s in original array    let orig_zero_count = 0;     // Consider all Subarrays by using two nested two    // loops    for (let i=0; i<n; i++)    {        // Increment count of zeros        if (arr[i] == 0)            orig_zero_count++;         // Initialize counts of 0s and 1s        let 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 (let j=i; j<n; j++)        {            (arr[j] == 1)? count1++ : 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 program    let arr = [0, 1, 0, 0, 1, 1, 0];    let n = arr.length;    document.write(findMaxZeroCount(arr, n)); // This code is contributed by Surbhi Tyagi. </script>
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++
Java
Python3
C#
Javascript
// C++ program to maximize number of zeroes in a// binary array by at most one flip operation#include<bits/stdc++.h>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<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 = 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 programint main(){    bool arr[] = {0, 1, 0, 0, 1, 1, 0};    int n = sizeof(arr)/sizeof(arr[0]);    cout << findMaxZeroCount(arr, n);    return 0;}
// Java code for Maximize number of 0s by// flipping a subarrayclass 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 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 codearr = [ 0, 1, 0, 0, 1, 1, 0 ]n = len(arr) print(findMaxZeroCount(arr, n)) # This code is contributed by stutipathak31jan
// C# code for Maximize number of 0s by// flipping a subarrayusing 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
<script> // JavaScript 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.function findMaxZeroCount(arr, n){    // Initialize count of    // zeros and maximum difference    // between count of 1s and 0s in    // a subarray    var orig_zero_count = 0;     // Initiale overall max diff for any subarray    var max_diff = 0;     // Initialize current diff    var curr_max = 0;     for (var 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        var val;        if (arr[i] == 1)        val=1;        else        val=-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;}     var arr = [0, 1, 0, 0, 1, 1, 0];    var n=7;    document.write(findMaxZeroCount(arr, n));         // This Code is Contributed by Harshit Srivastava     </script>
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 review-team@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. 
stutipathak31jan
Amal Kumar Choubey
Rohit_ranjan
srivastavaharshit848
surbhityagi15
Vishal Shirke
Amazon
Kadane
Arrays
Amazon
Arrays
Kadane
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
Stack Data Structure (Introduction and Program)
Top 50 Array Coding Problems for Interviews
Introduction to Arrays
Multidimensional Arrays in Java
Linear Search
Python | Using 2D arrays/lists the right way
Linked List vs Array
Maximum and minimum of an array using minimum number of comparisons
Given an array of size n and a number k, find all elements that appear more than n/k times
Queue | Set 1 (Introduction and Array Implementation)