Maximize number of 0s by flipping a subarray
Last Updated :
20 Feb, 2023
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++
#include<bits/stdc++.h>
using namespace std;
int findMaxZeroCount( bool arr[], int n)
{
int max_diff = 0;
int orig_zero_count = 0;
for ( int i=0; i<n; i++)
{
if (arr[i] == 0)
orig_zero_count++;
int count1 = 0, count0 = 0;
for ( int j=i; j<n; j++)
{
(arr[j] == 1)? count1++ : count0++;
max_diff = max(max_diff, count1 - count0);
}
}
return orig_zero_count + max_diff;
}
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
class GFG {
public static int findMaxZeroCount( int arr[], int n)
{
int max_diff = 0 ;
int orig_zero_count = 0 ;
for ( int i= 0 ; i<n; i++)
{
if (arr[i] == 0 )
orig_zero_count++;
int count1 = 0 , count0 = 0 ;
for ( int j = i; j < n; j ++)
{
if (arr[j] == 1 )
count1++;
else count0++;
max_diff = Math.max(max_diff, count1 - count0);
}
}
return orig_zero_count + max_diff;
}
public static void main(String[] args)
{
int arr[] = { 0 , 1 , 0 , 0 , 1 , 1 , 0 };
System.out.println(findMaxZeroCount(arr, arr.length));
}
}
|
Python3
def findMaxZeroCount(arr, n):
max_diff = 0
orig_zero_count = 0
for i in range (n):
if arr[i] = = 0 :
orig_zero_count + = 1
count1, count0 = 0 , 0
for j in range (i, n):
if arr[j] = = 1 :
count1 + = 1
else :
count0 + = 1
max_diff = max (max_diff, count1 -
count0)
return orig_zero_count + max_diff
arr = [ 0 , 1 , 0 , 0 , 1 , 1 , 0 ]
n = len (arr)
print (findMaxZeroCount(arr, n))
|
C#
using System;
class GFG{
public static int findMaxZeroCount( int []arr,
int n)
{
int max_diff = 0;
int orig_zero_count = 0;
for ( int i = 0; i < n; i++)
{
if (arr[i] == 0)
orig_zero_count++;
int count1 = 0, count0 = 0;
for ( int j = i; j < n; j ++)
{
if (arr[j] == 1)
count1++;
else count0++;
max_diff = Math.Max(max_diff,
count1 - count0);
}
}
return orig_zero_count + max_diff;
}
public static void Main(String[] args)
{
int []arr = { 0, 1, 0, 0, 1, 1, 0 };
Console.WriteLine(
findMaxZeroCount(arr, arr.Length));
}
}
|
Javascript
<script>
function findMaxZeroCount(arr, n)
{
let max_diff = 0;
let orig_zero_count = 0;
for (let i=0; i<n; i++)
{
if (arr[i] == 0)
orig_zero_count++;
let count1 = 0, count0 = 0;
for (let j=i; j<n; j++)
{
(arr[j] == 1)? count1++ : count0++;
max_diff = Math.max(max_diff, count1 - count0);
}
}
return orig_zero_count + max_diff;
}
let arr = [0, 1, 0, 0, 1, 1, 0];
let n = arr.length;
document.write(findMaxZeroCount(arr, n));
</script>
|
Time Complexity: O(n2)
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++
#include<bits/stdc++.h>
using namespace std;
int findMaxZeroCount( bool arr[], int n)
{
int orig_zero_count = 0;
int max_diff = 0;
int curr_max = 0;
for ( int i=0; i<n; i++)
{
if (arr[i] == 0)
orig_zero_count++;
int val = (arr[i] == 1)? 1 : -1;
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;
}
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
class GFG {
public static int findMaxZeroCount( int arr[], int n)
{
int orig_zero_count = 0 ;
int max_diff = 0 ;
int curr_max = 0 ;
for ( int i = 0 ; i < n; i ++)
{
if (arr[i] == 0 )
orig_zero_count ++;
int val = (arr[i] == 1 )? 1 : - 1 ;
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;
}
public static void main(String[] args)
{
int arr[] = { 0 , 1 , 0 , 0 , 1 , 1 , 0 };
System.out.println(findMaxZeroCount(arr, arr.length));
}
}
|
Python3
def findMaxZeroCount(arr, n):
orig_zero_count = 0
max_diff = 0
curr_max = 0
for i in range (n):
if arr[i] = = 0 :
orig_zero_count + = 1
val = 1 if arr[i] = = 1 else - 1
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
arr = [ 0 , 1 , 0 , 0 , 1 , 1 , 0 ]
n = len (arr)
print (findMaxZeroCount(arr, n))
|
C#
using System;
class GFG{
public static int findMaxZeroCount( int []arr, int n)
{
int orig_zero_count = 0;
int max_diff = 0;
int curr_max = 0;
for ( int i = 0; i < n; i ++)
{
if (arr[i] == 0)
orig_zero_count ++;
int val = (arr[i] == 1)? 1 : -1;
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;
}
public static void Main(String[] args)
{
int []arr = {0, 1, 0, 0, 1, 1, 0};
Console.WriteLine(findMaxZeroCount(arr, arr.Length));
}
}
|
Javascript
<script>
function findMaxZeroCount(arr, n)
{
var orig_zero_count = 0;
var max_diff = 0;
var curr_max = 0;
for ( var i=0; i<n; i++)
{
if (arr[i] == 0)
orig_zero_count++;
var val;
if (arr[i] == 1)
val=1;
else
val=-1;
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));
</script>
|
Time Complexity: O(n)
Auxiliary Space: O(1)
As constant extra space is used.
Like Article
Suggest improvement
Share your thoughts in the comments
Please Login to comment...