# Minimum inversions required so that no two adjacent elements are same

• Difficulty Level : Medium
• Last Updated : 01 Mar, 2022

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 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 ``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);` `    ``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

 ``

Output:

`3`

Time Complexity: O(n)

Auxiliary Space: O(1)

My Personal Notes arrow_drop_up