Minimum inversions required so that no two adjacent elements are same

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: 1 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: 3  
 
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++
Java
Python3
C#
Javascript
// 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 sameint 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 codeint 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 implementation of the approachclass GFG{ // Function to return the minimum// inversions required so that no// two adjacent elements are samestatic 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 codepublic 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 implementation of the approach # Function to return the minimum# inversions required so that no# two adjacent elements are samedef 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 codeif __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# implementation of the approachusing System; class GFG{ // Function to return the minimum// inversions required so that no// two adjacent elements are samestatic 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 codepublic 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
<script> // JavaScript implementation of the approach // Function to return the minimum// inversions required so that no// two adjacent elements are samefunction 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 codelet a = [1, 0, 0, 1, 0, 0, 1, 0];let n = a.length; document.write(min_changes(a, n)); </script>
3
 
Time Complexity: O(n)
Auxiliary Space: O(1)
Rajput-Ji
gfgking
subham348
Constructive Algorithms
Arrays
Mathematical
Arrays
Mathematical
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.