Skip to content
Related Articles

Related Articles

Minimum inversions required so that no two adjacent elements are same

View Discussion
Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 01 Mar, 2022
View Discussion
Improve Article
Save Article

Given a binary array arr[] of size N. The task is to find the minimum number of inversions required so that no two adjacent elements are same. After a single inversion, an element could change from 0 to 1 or from 1 to 0.
Examples: 
 

Input: arr[] = {1, 1, 1} 
Output:
Change arr[1] from 1 to 0 and 
the array becomes {1, 0, 1}.
Input: arr[] = {1, 0, 0, 1, 0, 0, 1, 0} 
Output:
 

 

Approach: There are only two possibilities to make the array {1, 0, 1, 0, 1, 0, 1, …} or {0, 1, 0, 1, 0, 1, 0, …}. Let ans_a and ans_b be the count of changes required to get these arrays respectively. Now, the final answer will be min(ans_a, ans_b).
Below is the implementation of the above approach: 
 

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the minimum
// inversions required so that no
// two adjacent elements are same
int min_changes(int a[], int n)
{
    // To store the inversions required
    // to make the array {1, 0, 1, 0, 1, 0, 1, ...}
    // and {0, 1, 0, 1, 0, 1, 0, ...} respectively
    int ans_a = 0, ans_b = 0;
 
    // Find all the changes required
    for (int i = 0; i < n; i++) {
        if (i % 2 == 0) {
            if (a[i] == 0)
                ans_a++;
            else
                ans_b++;
        }
        else {
            if (a[i] == 0)
                ans_b++;
            else
                ans_a++;
        }
    }
 
    // Return the required answer
    return min(ans_a, ans_b);
}
 
// Driver code
int main()
{
    int a[] = { 1, 0, 0, 1, 0, 0, 1, 0 };
    int n = sizeof(a) / sizeof(a[0]);
 
    cout << min_changes(a, n);
 
    return 0;
}

Java




// Java implementation of the approach
class GFG
{
 
// Function to return the minimum
// inversions required so that no
// two adjacent elements are same
static int min_changes(int a[], int n)
{
    // To store the inversions required
    // to make the array {1, 0, 1, 0, 1, 0, 1, ...}
    // and {0, 1, 0, 1, 0, 1, 0, ...} respectively
    int ans_a = 0, ans_b = 0;
 
    // Find all the changes required
    for (int i = 0; i < n; i++)
    {
        if (i % 2 == 0)
        {
            if (a[i] == 0)
                ans_a++;
            else
                ans_b++;
        }
        else
        {
            if (a[i] == 0)
                ans_b++;
            else
                ans_a++;
        }
    }
 
    // Return the required answer
    return Math.min(ans_a, ans_b);
}
 
// Driver code
public static void main(String[] args)
{
    int a[] = { 1, 0, 0, 1, 0, 0, 1, 0 };
    int n = a.length;
 
    System.out.println(min_changes(a, n));
}
}
 
// This code is contributed by Rajput-Ji

Python3




# Python3 implementation of the approach
 
# Function to return the minimum
# inversions required so that no
# two adjacent elements are same
def min_changes(a, n):
 
    # To store the inversions required
    # to make the array {1, 0, 1, 0, 1, 0, 1, ...}
    # and {0, 1, 0, 1, 0, 1, 0, ...} respectively
    ans_a = 0;
    ans_b = 0;
 
    # Find all the changes required
    for i in range(n):
        if (i % 2 == 0):
            if (a[i] == 0):
                ans_a += 1;
            else:
                ans_b += 1;
 
        else:
            if (a[i] == 0):
                ans_b += 1;
            else:
                ans_a += 1;
 
    # Return the required answer
    return min(ans_a, ans_b);
 
# Driver code
if __name__ == '__main__':
 
    a = [ 1, 0, 0, 1, 0, 0, 1, 0 ];
    n = len(a);
 
    print(min_changes(a, n));
 
# This code is contributed by Rajput-Ji

C#




// C# implementation of the approach
using System;
 
class GFG
{
 
// Function to return the minimum
// inversions required so that no
// two adjacent elements are same
static int min_changes(int []a, int n)
{
    // To store the inversions required
    // to make the array {1, 0, 1, 0, 1, 0, 1, ...}
    // and {0, 1, 0, 1, 0, 1, 0, ...} respectively
    int ans_a = 0, ans_b = 0;
 
    // Find all the changes required
    for (int i = 0; i < n; i++)
    {
        if (i % 2 == 0)
        {
            if (a[i] == 0)
                ans_a++;
            else
                ans_b++;
        }
        else
        {
            if (a[i] == 0)
                ans_b++;
            else
                ans_a++;
        }
    }
 
    // Return the required answer
    return Math.Min(ans_a, ans_b);
}
 
// Driver code
public static void Main(String[] args)
{
    int []a = { 1, 0, 0, 1, 0, 0, 1, 0 };
    int n = a.Length;
 
    Console.WriteLine(min_changes(a, n));
}
}
 
// This code is contributed by Rajput-Ji

Javascript




<script>
 
// JavaScript implementation of the approach
 
// Function to return the minimum
// inversions required so that no
// two adjacent elements are same
function min_changes(a, n) {
    // To store the inversions required
    // to make the array {1, 0, 1, 0, 1, 0, 1, ...}
    // and {0, 1, 0, 1, 0, 1, 0, ...} respectively
    let ans_a = 0, ans_b = 0;
 
    // Find all the changes required
    for (let i = 0; i < n; i++) {
        if (i % 2 == 0) {
            if (a[i] == 0)
                ans_a++;
            else
                ans_b++;
        }
        else {
            if (a[i] == 0)
                ans_b++;
            else
                ans_a++;
        }
    }
 
    // Return the required answer
    return Math.min(ans_a, ans_b);
}
 
// Driver code
let a = [1, 0, 0, 1, 0, 0, 1, 0];
let n = a.length;
 
document.write(min_changes(a, n));
 
</script>

Output: 

3

 

Time Complexity: O(n)

Auxiliary Space: O(1)


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!