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(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 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
// 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
# 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#
// 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 |
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 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
// 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
# 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#
// 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 |
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.
Please Login to comment...