Número máximo de 0 que se pueden voltear de modo que Array no tenga 1 adyacentes

Dada una array binaria arr , la tarea es encontrar el número máximo de 0 que se pueden voltear de manera que la array no tenga 1 adyacentes, es decir, la array no contenga dos 1 en índices consecutivos.
Ejemplos: 
 

Entrada: arr[] = {1, 0, 0, 0, 1} 
Salida: 1 
Explicación: 
El 0 en el índice 2 se puede reemplazar por 1.
Entrada: arr[] = {1, 0, 0, 1} 
Salida: 0 
Explicación: 
Ningún 0 (ceros) puede ser reemplazado por 1 de modo que no haya dos índices consecutivos que tengan 1. 
 

Acercarse: 
 

• Itere sobre la array y para cada índice que tenga 0, verifique si sus dos índices adyacentes tienen 0 o no. Para el último y el primer índice de la array, verifique el índice izquierdo y derecho adyacentes, respectivamente.
• Por cada índice que satisfaga la condición anterior, aumente el conteo.
• Imprime el conteo final al final como la respuesta requerida

El siguiente código es la implementación del enfoque anterior: 
 

// C++ program for the above approach
#include<bits/stdc++.h>
using namespace std;
 
// Maximum number of 0s that
// can be replaced by 1
int canReplace(int array[], int n)
{
    int i = 0, count = 0;
 
    while (i < n)
    {
         
        // Check for three consecutive 0s
        if (array[i] == 0 &&
            (i == 0 || array[i - 1] == 0) &&
            (i == n - 1|| array[i + 1] == 0))
        {
 
            // Flip the bit
            array[i] = 1;
 
            // Increase the count
            count++;
        }
        i++;
    }
    return count;
}
 
// Driver's Code
int main()
{
    int array[5] = { 1, 0, 0, 0, 1 };    
     
    cout << canReplace(array, 5);
}
 
// This code is contributed by spp____

// Java program for the above approach
 
public class geeks {
 
    // Maximum number of 0s that
    // can be replaced by 1
    public static int canReplace(
        int[] array)
    {
        int i = 0, count = 0;
 
        while (i < array.length) {
 
            // Check for three consecutive 0s
            if (array[i] == 0
                && (i == 0
                    || array[i - 1] == 0)
                && (i == array.length - 1
                    || array[i + 1] == 0)) {
 
                // Flip the bit
                array[i] = 1;
 
                // Increase the count
                count++;
            }
            i++;
        }
 
        return count;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int[] array = { 1, 0, 0, 0, 1 };
        System.out.println(canReplace(array));
    }
}

# Python3 program for the above approach
 
# Maximum number of 0s that
# can be replaced by 1
def canReplace(arr, n):
 
    i = 0
    count = 0
 
    while (i < n):
 
        # Check for three consecutive 0s
        if (arr[i] == 0 and
                (i == 0 or arr[i - 1] == 0) and
                (i == n - 1 or arr[i + 1] == 0)):
 
            # Flip the bit
            arr[i] = 1
 
            # Increase the count
            count += 1
 
        i += 1
    return count
 
# Driver code
if __name__ == '__main__':
 
    arr = [ 1, 0, 0, 0, 1]
     
    print(canReplace(arr, 5))
 
# This code is contributed by himanshu77

// C# program for the above approach
using System;
 
class GFG{
 
// Maximum number of 0s that
// can be replaced by 1
public static int canReplace(int[] array)
{
    int i = 0, count = 0;
    while (i < array.Length)
    {
 
        // Check for three consecutive 0s
        if (array[i] == 0 &&
           (i == 0 || array[i - 1] == 0) &&
           (i == array.Length - 1 || array[i + 1] == 0))
        {
             
            // Flip the bit
            array[i] = 1;
 
            // Increase the count
            count++;
        }
        i++;
    }
 
    return count;
}
 
// Driver code
public static void Main(String []args)
{
    int[] array = { 1, 0, 0, 0, 1 };
     
    Console.WriteLine(canReplace(array));
}
}
 
// This code is contributed by Rajput-Ji

<script>
 
// Javascript program for
// the above approach
 
// Maximum number of 0s that
// can be replaced by 1
function canReplace(array, n)
{
    var i = 0, count = 0;
 
    while (i < n)
    {
         
        // Check for three consecutive 0s
        if (array[i] == 0 &&
            (i == 0 || array[i - 1] == 0) &&
            (i == n - 1|| array[i + 1] == 0))
        {
 
            // Flip the bit
            array[i] = 1;
 
            // Increase the count
            count++;
        }
        i++;
    }
    return count;
}
 
// Driver's Code
    array = [1, 0, 0, 0, 1]    
     
    document.write(canReplace(array, 5));
 
</script>

1

Complejidad de tiempo: O(N)