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

Last Updated : 27 Jan, 2022

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# 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)

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

code_r

Improve

Article Tags :

Practice Tags :

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

Similar Reads

Thank You!

What kind of Experience do you want to share?