Open In App

# Minimum subarray reversals required to make given binary array alternating

Given a binary array arr[] consisting of equal count of 0s and 1s, the task is to count the minimum number of subarray reversal operations required to make the binary array alternating. In each operation reverse any subarray of the given array.

Examples:

Input: arr[] = { 1, 1, 1, 0, 1, 0, 0, 0 }
Output:
Explanation:
Reversing the subarray {arr[1], …, arr[5]} modifies arr[] to { 1, 0, 1, 0, 1, 1, 0, 0 }
Reversing the subarray {arr[5], arr[6]} modifies arr[] to { 1, 0, 1, 0, 1, 0, 1, 0 }, which is alternating. Therefore, the required output is 2.

Input: arr[] = { 0, 1, 1, 0 }
Output:
Explanation:
Reversing the subarray {arr[2], …, arr[2]} modifies arr[] to { 0, 1, 0, 1 }, which is alternating. Therefore, the required output is 1.

Approach: The problem can be solved using Greedy technique. The idea is to count the array elements which are not present at correct indices for the array to be alternating, i.e. count the consecutive equal elements present the given array. Follow the steps below to solve the problem:

• Initialize a variable, say cntOp, to store the minimum count of subarray reversal operations required to make the given array alternating.
• Traverse the array using variable i and for every array element arr[i], check if it is equal to arr[i + 1] or not. If found to be true, then increment the value of cntOp.
• Finally, print the value of (cntOp + 1) / 2.

Below is the implementation of the above approach:

## C++

 // C++ program to implement// the above approach #include using namespace std; // Function to count minimum subarray reversal// operations required to make array alternatingint minimumcntOperationReq(int arr[], int N){    // Stores minimum count of operations    // required to make array alternating    int cntOp = 0;     // Traverse the array    for (int i = 0; i < N - 1; i++) {         // If arr[i] is greater        // than arr[i + 1]        if (arr[i] == arr[i + 1]) {             // Update cntOp            cntOp++;        }    }     return (cntOp + 1) / 2;} // Driver Codeint main(){    int arr[] = { 1, 1, 1, 0, 1, 0, 0, 0 };     int N = sizeof(arr) / sizeof(arr[0]);     cout << minimumcntOperationReq(arr, N);     return 0;}

## Java

 // Java program to implement// the above approachimport java.util.*;  class GFG{  // Function to count minimum subarray reversal// operations required to make array alternatingstatic int minimumcntOperationReq(int arr[], int N){         // Stores minimum count of operations    // required to make array alternating    int cntOp = 0;      // Traverse the array    for(int i = 0; i < N - 1; i++)    {                 // If arr[i] is greater        // than arr[i + 1]        if (arr[i] == arr[i + 1])        {                         // Update cntOp            cntOp++;        }    }    return (cntOp + 1) / 2;}  // Driver Codepublic static void main(String[] args){    int arr[] = { 1, 1, 1, 0, 1, 0, 0, 0 };    int N = arr.length;      System.out.print(minimumcntOperationReq(arr, N));}} // This code is contributed by code_hunt

## Python3

 # Python3 program to implement# the above approach  # Function to count minimum subarray# reversal operations required to make# array alternatingdef minimumcntOperationReq(arr, N):         # Stores minimum count of operations    # required to make array alternating    cntOp = 0      # Traverse the array    for i in range(N - 1):          # If arr[i] is greater        # than arr[i + 1]        if (arr[i] == arr[i + 1]):              # Update cntOp            cntOp += 1                 return (cntOp + 1) // 2 # Driver Codearr = [ 1, 1, 1, 0, 1, 0, 0, 0 ]  N = len(arr)  print(minimumcntOperationReq(arr, N)) # This code is contributed by susmitakundugoaldanga

## C#

 // C# program to implement// the above approachusing System;class GFG{         // Function to count minimum subarray reversal    // operations required to make array alternating    static int minimumcntOperationReq(int[] arr, int N)    {               // Stores minimum count of operations        // required to make array alternating        int cntOp = 0;              // Traverse the array        for (int i = 0; i < N - 1; i++)        {                  // If arr[i] is greater            // than arr[i + 1]            if (arr[i] == arr[i + 1])            {                      // Update cntOp                cntOp++;            }        }              return (cntOp + 1) / 2;    }     // Driver code  static void Main()  {        int[] arr = { 1, 1, 1, 0, 1, 0, 0, 0 };          int N = arr.Length;              Console.WriteLine(minimumcntOperationReq(arr, N));  }} // This code is contributed by divyeshrabadiya07

## Javascript



Output:

2

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