Skip to content
Related Articles

Related Articles

Maximize number of 0s by flipping a subarray

Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 04 Jul, 2022
Improve Article
Save Article

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<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 program
int main()
{
    bool arr[] = {0, 1, 0, 0, 1, 1, 0};
    int n = sizeof(arr)/sizeof(arr[0]);
    cout << findMaxZeroCount(arr, n);
    return 0;
}

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<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




# 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




<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++




// 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 program
int main()
{
    bool arr[] = {0, 1, 0, 0, 1, 1, 0};
    int n = sizeof(arr)/sizeof(arr[0]);
    cout << findMaxZeroCount(arr, n);
    return 0;
}

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




<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. 


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!