Check if K 0s can be flipped such that the given Array has no adjacent 1s

Last Updated : 23 Jul, 2025

Given a binary array arr[] of size N, and an integer K, the task is to check if K 0s can be flipped such that the array has no adjacent 1s.

Examples:

Input: arr[] = {0, 0, 0, 0, 1}, K=2
Output: true
Explanation: The 0 at indices 0 and 2 can be replaced by 1. 
Hence 2 elements can be flipped (=K).

Input: arr[] = {1, 0, 0, 0, 1}, K = 2
Output: false
Explanation: The 0 at index 2 can be replaced by 1. 
Hence 1 element can be flipped (!= K).

 

Approach: The solution is based on greedy approach. Please follow the steps mentioned below:

  • Iterate over the array and for every index which has 0, check if its adjacent two indices have 0 or not. For each possible flip, decrement the count of K.
  • For the last and first index of the array, check for the adjacent left and right index respectively.
  • For every such index satisfying the above condition, Decrement the count of K if it is possible.
  • Return true if K<=0, else return false.

Below is the implementation of the above approach.

C++ 
// C++ code to implement the approach
#include <bits/stdc++.h>
using namespace std;

// Function to check 
// the possibility of K flips
bool flips(vector<int>& arr, int K)
{
    if (arr[0] == 0 && (arr.size() == 1 
                      || arr[1] == 0)) {
        arr[0] = 1;
        K--;
    }

    for (int i = 1; i < arr.size() - 1; 
         i++) {
        if (arr[i - 1] == 0 && arr[i] == 0 
            && arr[i + 1] == 0) {
            arr[i] = 1;
            K--;
        }
    }

    if (arr.size() > 1 
        && arr[arr.size() - 2] == 0
        && arr[arr.size() - 1] == 0) {
        arr[arr.size() - 1] = 1;
        K--;
    }

    return K <= 0;
}

// Driver code
int main()
{
    vector<int> arr = { 0, 0, 0, 0, 1 };
    int K = 2;
    cout << (flips(arr, K) ? "true" : "false");
    return 0;
}
Java 
// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;

class GFG {

  // Function to check 
  // the possibility of K flips
  static Boolean flips(int arr[], int K)
  {
    if (arr[0] == 0 && (arr.length == 1 
                        || arr[1] == 0)) {
      arr[0] = 1;
      K--;
    }

    for (int i = 1; i < arr.length - 1; 
         i++) {
      if (arr[i - 1] == 0 && arr[i] == 0 
          && arr[i + 1] == 0) {
        arr[i] = 1;
        K--;
      }
    }

    if (arr.length > 1 
        && arr[arr.length - 2] == 0
        && arr[arr.length - 1] == 0) {
      arr[arr.length - 1] = 1;
      K--;
    }

    return K <= 0;
  }

  // Driver code
  public static void main (String[] args) {
    int arr[] = { 0, 0, 0, 0, 1 };
    int K = 2;
    System.out.println(flips(arr, K) ? "true" : "false");
  }
}

// This code is contributed by hrithikgarg03188
Python3 
# Python code for the above approach 

# Function to check 
# the possibility of K flips
def flips(arr, K):
    if (arr[0] == 0 and (len(arr) == 1 or arr[1] == 0)):
        arr[0] = 1;
        K -= 1

    for i in range(1, len(arr) - 1):
        if (arr[i - 1] == 0 and arr[i] == 0
            and arr[i + 1] == 0):
            arr[i] = 1;
            K -= 1

    if (len(arr) > 1
        and arr[len(arr) - 2] == 0
        and arr[len(arr) - 1] == 0):
        arr[len(arr) - 1] = 1;
        K -= 1

    return K <= 0;

# Driver code
arr = [0, 0, 0, 0, 1];
K = 2;
if (flips(arr, K)):
    print("true");
else:
    print("false");

# This code is contributed by Saurabh Jaiswal
C# 
// C# program for the above approach
using System;
class GFG {

  // Function to check 
  // the possibility of K flips
  static Boolean flips(int[] arr, int K)
  {
    if (arr[0] == 0 && (arr.Length == 1  || arr[1] == 0)) {
      arr[0] = 1;
      K--;
    }

    for (int i = 1; i < arr.Length - 1; 
         i++) {
      if (arr[i - 1] == 0 && arr[i] == 0 
          && arr[i + 1] == 0) {
        arr[i] = 1;
        K--;
      }
    }

    if (arr.Length > 1 
        && arr[arr.Length - 2] == 0
        && arr[arr.Length - 1] == 0) {
      arr[arr.Length - 1] = 1;
      K--;
    }

    return K <= 0;
  }

  // Driver code
  public static void Main () {
    int[] arr = { 0, 0, 0, 0, 1 };
    int K = 2;
    Console.Write(flips(arr, K) ? "true" : "false");
  }
}

// This code is contributed by Saurabh Jaiswal
JavaScript 
 <script>
        // JavaScript code for the above approach 

        // Function to check 
        // the possibility of K flips
        function flips(arr, K) {
            if (arr[0] == 0 && (arr.length == 1
                || arr[1] == 0)) {
                arr[0] = 1;
                K--;
            }

            for (let i = 1; i < arr.length - 1;
                i++) {
                if (arr[i - 1] == 0 && arr[i] == 0
                    && arr[i + 1] == 0) {
                    arr[i] = 1;
                    K--;
                }
            }

            if (arr.length > 1
                && arr[arr.length - 2] == 0
                && arr[arr.length - 1] == 0) {
                arr[arr.length - 1] = 1;
                K--;
            }

            return K <= 0;
        }

        // Driver code

        let arr = [0, 0, 0, 0, 1];
        let K = 2;
        if (flips(arr, K))
            document.write("true");
        else
            document.write("false");

         // This code is contributed by Potta Lokesh
    </script>

 
 


Output
true


 

Time Complexity: O(N)
Auxiliary Space: O(1)


 

Comment

Explore