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

Method 1 (Simple : O(n²)): 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

Time Complexity: O(n²)

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

Time Complexity: O(n)

Auxiliary Space: O(1)

As constant extra space is used.

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.