Open In App

Minimum flips of odd indexed elements from odd length subarrays to make two given arrays equal

Improve
Improve
Like Article
Like
Save
Share
Report

Given two binary arrays X[] and Y[] of size N, the task is to convert array X[] into array Y[] by minimum number of operations of selecting any subarray of odd length and flipping all odd-indexed elements from the subarray.

Examples:

Input: X[] = {1, 0, 0, 0, 0, 1}, Y[] = {1, 1, 0, 1, 1, 1}
Output: 2
Explanation:
Initially, X[] is {1, 0, 0, 0, 0, 1}.
Operation 1: Choose the sub-array {0, 0, 0} from array X[] and change the 2nd and 4th character and convert it to {1, 0, 1}.
Now X becomes {1, 1, 0, 1, 0, 1}.
Operation 2: Choose the sub-array {0} containing only the 5th character and convert it to 1.
Finally, X becomes {1, 1, 0, 1, 1, 1}, which is equal to Y.
Therefore, the count of operations is 2.

Input: X[] = {0, 1, 0}, Y[] = {0, 1, 0}
Output: 0
Explanation:
Since both the arrays X and Y are equal thus the minimum operations would be 0.

Approach: The idea is to count the operations for both even and odd positions individually. Follow the steps below to solve the problem:

  • Initialize a variable C as 0 to store the count of operations.
  • Traverse the array X[] elements over odd positions and take a counter count = 0.
    • Check for consecutive unequal elements between X[i] and Y[i] and increase the counter count by 1 every time.
    • When X[i] and Y[i] are equal increase a global C to increase operation by 1 since in that one operation all odd positions can be made equal to as in Y.
  • Similarly, Traverse the array X[] elements over even positions and again take a counter count = 0.
    • Check for consecutive unequal elements between X[i] and Y[i] and increase the counter count by 1 every time.
    • When X[i] and Y[i] are equal increase a global counter C to increase operation by 1.
  • After the above steps, print the value of C as the resultant count of operations required.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the minimum flip
// of subarrays required at alternate
// index to make binary arrays equals
void minOperation(int X[], int Y[],
                  int n)
{
    // Stores count of total operations
    int C = 0;
 
    // Stores count of consecutive
    // unequal elements
    int count = 0;
 
    // Loop to run on odd positions
    for (int i = 1; i < n; i = i + 2) {
 
        if (X[i] != Y[i]) {
            count++;
        }
        else {
 
            // Incrementing the
            // global counter
            if (count != 0)
                C++;
 
            // Change count to 0
            count = 0;
        }
    }
 
    // If all last elements are equal
    if (count != 0)
        C++;
 
    count = 0;
 
    // Loop to run on even positions
    for (int i = 0; i < n; i = i + 2) {
 
        if (X[i] != Y[i]) {
            count++;
        }
        else {
 
            // Incrementing the
            // global counter
            if (count != 0)
                C++;
 
            // Change count to 0
            count = 0;
        }
    }
 
    if (count != 0)
        C++;
 
    // Print the minimum operations
    cout << C;
}
 
// Driver Code
int main()
{
    int X[] = { 1, 0, 0, 0, 0, 1 };
    int Y[] = { 1, 1, 0, 1, 1, 1 };
    int N = sizeof(X) / sizeof(X[0]);
 
    // Function Call
    minOperation(X, Y, N);
 
    return 0;
}


Java




// Java program for the above approach
import java.util.*;
    
class GFG{
    
// Function to find the minimum flip
// of subarrays required at alternate
// index to make binary arrays equals
static void minOperation(int X[], int Y[],
                         int n)
{
     
    // Stores count of total operations
    int C = 0;
  
    // Stores count of consecutive
    // unequal elements
    int count = 0;
  
    // Loop to run on odd positions
    for(int i = 1; i < n; i = i + 2)
    {
         
        if (X[i] != Y[i])
        {
            count++;
        }
        else
        {
             
            // Incrementing the
            // global counter
            if (count != 0)
                C++;
  
            // Change count to 0
            count = 0;
        }
    }
  
    // If all last elements are equal
    if (count != 0)
        C++;
  
    count = 0;
  
    // Loop to run on even positions
    for(int i = 0; i < n; i = i + 2)
    {
        if (X[i] != Y[i])
        {
            count++;
        }
        else
        {
             
            // Incrementing the
            // global counter
            if (count != 0)
                C++;
  
            // Change count to 0
            count = 0;
        }
    }
  
    if (count != 0)
        C++;
  
    // Print the minimum operations
    System.out.print(C);
}
    
// Driver Code
public static void main(String[] args)
{
    int X[] = { 1, 0, 0, 0, 0, 1 };
    int Y[] = { 1, 1, 0, 1, 1, 1 };
    int N = X.length;
  
    // Function Call
    minOperation(X, Y, N);
}
}
 
// This code is contributed by susmitakundugoaldanga


Python3




# Python program for the above approach
 
# Function to find the minimum flip
# of subarrays required at alternate
# index to make binary arrays equals
def minOperation(X, Y, n):
   
    # Stores count of total operations
    C = 0;
 
    # Stores count of consecutive
    # unequal elements
    count = 0;
 
    # Loop to run on odd positions
    for i in range(1, n, 2):
 
        if (X[i] != Y[i]):
            count += 1;
        else:
 
            # Incrementing the
            # global counter
            if (count != 0):
                C += 1;
 
            # Change count to 0
            count = 0;
 
    # If all last elements are equal
    if (count != 0):
        C += 1;
 
    count = 0;
 
    # Loop to run on even positions
    for i in range(0, n, 2):
        if (X[i] != Y[i]):
            count += 1;
        else:
 
            # Incrementing the
            # global counter
            if (count != 0):
                C += 1;
 
            # Change count to 0
            count = 0;
 
    if (count != 0):
        C += 1;
 
    # Print minimum operations
    print(C);
 
# Driver Code
if __name__ == '__main__':
    X = [1, 0, 0, 0, 0, 1];
    Y = [1, 1, 0, 1, 1, 1];
    N = len(X);
 
    # Function Call
    minOperation(X, Y, N);
 
    # This code is contributed by 29AjayKumar


C#




// C# program for the above approach
using System;
 
class GFG{
    
// Function to find the minimum flip
// of subarrays required at alternate
// index to make binary arrays equals
static void minOperation(int []X, int []Y,
                         int n)
{
     
    // Stores count of total operations
    int C = 0;
  
    // Stores count of consecutive
    // unequal elements
    int count = 0;
  
    // Loop to run on odd positions
    for(int i = 1; i < n; i = i + 2)
    {
        if (X[i] != Y[i])
        {
            count++;
        }
        else
        {
             
            // Incrementing the
            // global counter
            if (count != 0)
                C++;
  
            // Change count to 0
            count = 0;
        }
    }
  
    // If all last elements are equal
    if (count != 0)
        C++;
  
    count = 0;
  
    // Loop to run on even positions
    for(int i = 0; i < n; i = i + 2)
    {
        if (X[i] != Y[i])
        {
            count++;
        }
        else
        {
             
            // Incrementing the
            // global counter
            if (count != 0)
                C++;
  
            // Change count to 0
            count = 0;
        }
    }
  
    if (count != 0)
        C++;
  
    // Print the minimum operations
    Console.Write(C);
}
    
// Driver Code
public static void Main(String[] args)
{
    int []X = { 1, 0, 0, 0, 0, 1 };
    int []Y = { 1, 1, 0, 1, 1, 1 };
    int N = X.Length;
     
    // Function Call
    minOperation(X, Y, N);
}
}
 
// This code is contributed by Amit Katiyar


Javascript




<script>
// javascript program to implement
// the above approach
 
// Function to find the minimum flip
// of subarrays required at alternate
// index to make binary arrays equals
function minOperation(X, Y,
                         n)
{
      
    // Stores count of total operations
    let C = 0;
   
    // Stores count of consecutive
    // unequal elements
    let count = 0;
   
    // Loop to run on odd positions
    for(let i = 1; i < n; i = i + 2)
    {
          
        if (X[i] != Y[i])
        {
            count++;
        }
        else
        {
              
            // Incrementing the
            // global counter
            if (count != 0)
                C++;
   
            // Change count to 0
            count = 0;
        }
    }
   
    // If all last elements are equal
    if (count != 0)
        C++;
   
    count = 0;
   
    // Loop to run on even positions
    for(let i = 0; i < n; i = i + 2)
    {
        if (X[i] != Y[i])
        {
            count++;
        }
        else
        {
              
            // Incrementing the
            // global counter
            if (count != 0)
                C++;
   
            // Change count to 0
            count = 0;
        }
    }
   
    if (count != 0)
        C++;
   
    // Print the minimum operations
    document.write(C);
}
 
// Driver code
 
    let X = [ 1, 0, 0, 0, 0, 1 ];
    let Y = [ 1, 1, 0, 1, 1, 1 ];
    let N = X.length;
   
    // Function Call
    minOperation(X, Y, N);
    
   // This code is contributed by splevel62.
</script>


Output: 

2

 

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



Last Updated : 16 Sep, 2021
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads