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.

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.