 Open in App
Not now

# 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
Related Articles