Given a binary array arr[] of size N, the task is to find the maximum count of 0s that can be converted into 1s such that no pair of adjacent array elements are 1.
Examples:
Input: arr[] = { 1, 0, 0, 0, 1 }
Output: 1
Explanation:
Updating arr[2] to 1 modifies arr[] to { 1, 0, 1, 0, 1 }
Therefore, the required output is 1Input: arr[] = { 0, 0, 1, 0, 0, 0, 0, 1, 0, 0 }
Output: 3
Explanation:
Updating arr[0], arr[5] and arr[9] modifies arr[] to { 1, 0, 1, 0, 0, 1, 0, 1, 0, 1 }
Therefore, the required output is 3
Approach: The problem can be solved using Greedy technique. Follow the steps below to solve the problem:
- Insert 0 at the front and end of the array.
- Traverse the array, arr[]. In every ith iteration, check if arr[i], arr[i + 1] and arr[i + 2] are 0s or not. If found to be true, then increment the count and update arr[i + 1] = 1.
- Finally, print the count obtained.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to find the maximum count of 0s // required to be converted into 1s such // no pair of adjacent elements are 1 void maxPositionsOccupied(vector< int >& arr)
{ // Base Case
if (arr.size() == 0) {
cout << 0;
return ;
}
// Insert 0 at the end
// of the array
arr.push_back(0);
// Insert 0 at the front
// of the array
arr.insert(arr.begin(), 0);
// Stores the maximum count of 0s
// that can be converted into 1s
int ans = 0;
// Stores index of array elements
int i = 0;
// Traverse the array
while ((i < arr.size() - 2)) {
// If adjacent elements are 0s
if ((arr[i] == 0) && (arr[i + 1] == 0)
&& (arr[i + 2] == 0)) {
// Update ans
ans++;
// Update arr[i + 1]
arr[i + 1] = 1;
}
// Update i
i++;
}
// Print the answer
cout << ans;
} // Driver Code int main()
{ // Given binary array
vector< int > arr = { 1, 0, 0, 0, 1 };
// Prints the maximum 0 to 1
// conversions required
maxPositionsOccupied(arr);
return 0;
} |
// Java program for the above approach public class GFG
{ // Function to find the maximum count of 0s
// required to be converted into 1s such
// no pair of adjacent elements are 1
static void maxPositionsOccupied( int [] arr)
{
// Base Case
if (arr.length == 0 )
{
System.out.print( 0 );
return ;
}
// Stores the maximum count of 0s
// that can be converted into 1s
int ans = 0 ;
// Stores index of array elements
int i = 0 ;
// Traverse the array
while ((i < arr.length - 2 ))
{
// If adjacent elements are 0s
if ((arr[i] == 0 ) &&
(arr[i + 1 ] == 0 ) &&
(arr[i + 2 ] == 0 ))
{
// Update ans
ans++;
// Update arr[i + 1]
arr[i + 1 ] = 1 ;
}
// Update i
i++;
}
// Print the answer
System.out.print(ans);
}
// Driver code
public static void main(String[] args)
{
// Given binary array
int [] arr = { 1 , 0 , 0 , 0 , 1 };
// Prints the maximum 0 to 1
// conversions required
maxPositionsOccupied(arr);
}
} // This code is contributed by divyeshrabadiya07. |
# Python3 program for the above approach # Function to find the maximum count of 0s # required to be converted into 1s such # no pair of adjacent elements are 1 def maxPositionsOccupied(arr):
# Base Case
if ( len (arr) = = 0 ):
print ( 0 )
# Insert 0 at the end
# of the array
arr.append( 0 )
# Insert 0 at the front
# of the array
arr.insert( 0 , 0 )
# Stores the maximum count of 0s
# that can be converted into 1s
ans = 0
# Stores index of array elements
i = 0
# Traverse the array
while ((i < len (arr) - 2 )):
# If adjacent elements are 0s
if ((arr[i] = = 0 ) and
(arr[i + 1 ] = = 0 ) and
(arr[i + 2 ] = = 0 )):
# Update ans
ans + = 1
# Update arr[i + 1]
arr[i + 1 ] = 1
# Update i
i + = 1
# Print the answer
print (ans)
# Driver Code if __name__ = = '__main__' :
# Given binary array
arr = [ 1 , 0 , 0 , 0 , 1 ]
# Prints the maximum 0 to 1
# conversions required
maxPositionsOccupied(arr)
# This code is contributed by SURENDRA_GANGWAR |
// C# program for the above approach using System;
class GFG{
// Function to find the maximum count of 0s // required to be converted into 1s such // no pair of adjacent elements are 1 static void maxPositionsOccupied( int [] arr)
{ // Base Case
if (arr.Length == 0)
{
Console.Write(0);
return ;
}
// Stores the maximum count of 0s
// that can be converted into 1s
int ans = 0;
// Stores index of array elements
int i = 0;
// Traverse the array
while ((i < arr.Length - 2))
{
// If adjacent elements are 0s
if ((arr[i] == 0) &&
(arr[i + 1] == 0) &&
(arr[i + 2] == 0))
{
// Update ans
ans++;
// Update arr[i + 1]
arr[i + 1] = 1;
}
// Update i
i++;
}
// Print the answer
Console.Write(ans);
} // Driver code static void Main()
{ // Given binary array
int [] arr = { 1, 0, 0, 0, 1 };
// Prints the maximum 0 to 1
// conversions required
maxPositionsOccupied(arr);
} } // This code is contributed by divyesh072019 |
<script> // Javascript program for the above approach
// Function to find the maximum count of 0s
// required to be converted into 1s such
// no pair of adjacent elements are 1
function maxPositionsOccupied(arr)
{
// Base Case
if (arr.length == 0)
{
document.write(0);
return ;
}
// Stores the maximum count of 0s
// that can be converted into 1s
let ans = 0;
// Stores index of array elements
let i = 0;
// Traverse the array
while ((i < arr.length - 2))
{
// If adjacent elements are 0s
if ((arr[i] == 0) &&
(arr[i + 1] == 0) &&
(arr[i + 2] == 0))
{
// Update ans
ans++;
// Update arr[i + 1]
arr[i + 1] = 1;
}
// Update i
i++;
}
// Print the answer
document.write(ans);
}
// Given binary array
let arr = [ 1, 0, 0, 0, 1 ];
// Prints the maximum 0 to 1
// conversions required
maxPositionsOccupied(arr);
</script> |
1
Time Complexity: O(N)
Auxiliary Space: O(1)