Minimum swaps to make two arrays identical

• Difficulty Level : Hard
• Last Updated : 17 Nov, 2021

Given two arrays that have the same values but in a different order, we need to make a second array the same as a first array using the minimum number of swaps.
Examples:

Input  : arrA[] = {3, 6, 4, 8},
arrB[] = {4, 6, 8, 3}
Output : 2
we can make arrB to same as arrA in 2 swaps
which are shown below,
swap 4 with 8,   arrB = {8, 6, 4, 3}
swap 8 with 3,   arrB = {3, 6, 4, 8}

This problem can be solved by modifying the array B. We save the index of array A elements in array B i.e. if ith element of array A is at jth position in array B, then we will make arrB[i] = j
For above given example, modified array B will be, arrB = {3, 1, 0, 2}. This modified array represents the distribution of array A element in array B and our goal is to sort this modified array in a minimum number of swaps because after sorting only array B element will be aligned with array A elements.
Now count of minimum swaps for sorting an array can be found by visualizing the problem as a graph, this problem is already explained in previous article
So we count these swaps in a modified array and that will be our final answer.
Please see the below code for a better understanding.

C++

 // C++ program to make an array same to another// using minimum number of swap#include using namespace std; // Function returns the minimum number of swaps// required to sort the array// This method is taken from below post// https://www.geeksforgeeks.org/minimum-number-swaps-required-sort-array/int minSwapsToSort(int arr[], int n){    // Create an array of pairs where first    // element is array element and second element    // is position of first element    pair arrPos[n];    for (int i = 0; i < n; i++)    {        arrPos[i].first = arr[i];        arrPos[i].second = i;    }     // Sort the array by array element values to    // get right position of every element as second    // element of pair.    sort(arrPos, arrPos + n);     // To keep track of visited elements. Initialize    // all elements as not visited or false.    vector vis(n, false);     // Initialize result    int ans = 0;     // Traverse array elements    for (int i = 0; i < n; i++)    {        // already swapped and corrected or        // already present at correct pos        if (vis[i] || arrPos[i].second == i)            continue;         // find out the number of  node in        // this cycle and add in ans        int cycle_size = 0;        int j = i;        while (!vis[j])        {            vis[j] = 1;             // move to next node            j = arrPos[j].second;            cycle_size++;        }         // Update answer by adding current cycle.        ans += (cycle_size - 1);    }     // Return result    return ans;} // method returns minimum number of swap to make// array B same as array Aint minSwapToMakeArraySame(int a[], int b[], int n){    // map to store position of elements in array B    // we basically store element to index mapping.    map mp;    for (int i = 0; i < n; i++)        mp[b[i]] = i;     // now we're storing position of array A elements    // in array B.    for (int i = 0; i < n; i++)        b[i] = mp[a[i]];     /* We can uncomment this section to print modified      b array    for (int i = 0; i < N; i++)        cout << b[i] << " ";    cout << endl; */     // returning minimum swap for sorting in modified    // array B as final answer    return minSwapsToSort(b, n);} //    Driver code to test above methodsint main(){    int a[] = {3, 6, 4, 8};    int b[] = {4, 6, 8, 3};     int n = sizeof(a) / sizeof(int);    cout << minSwapToMakeArraySame(a, b, n);    return 0;}

Java

 // Java program to make an array same to another// using minimum number of swapimport java.io.*;import java.util.*; // Function returns the minimum number of swaps// required to sort the array// This method is taken from below post// https://www.geeksforgeeks.org/minimum-number-swaps-required-sort-array/class GFG{   static int minSwapsToSort(int arr[], int n)  {     // Create an array of pairs where first    // element is array element and second element    // is position of first element       ArrayList> arrPos = new ArrayList>();    for (int i = 0; i < n; i++)    {      arrPos.add(new ArrayList(Arrays.asList(arr[i],i)));    }     // Sort the array by array element values to    // get right position of every element as second    // element of pair.    Collections.sort(arrPos, new Comparator>() {         @Override      public int compare(ArrayList o1, ArrayList o2) {        return o1.get(0).compareTo(o2.get(0));      }                  });     // To keep track of visited elements. Initialize    // all elements as not visited or false.    boolean[] vis = new boolean[n];     // Initialize result    int ans = 0;     // Traverse array elements    for (int i = 0; i < n; i++)    {       // already swapped and corrected or      // already present at correct pos      if (vis[i] || arrPos.get(i).get(1) == i)        continue;       // find out the number of  node in      // this cycle and add in ans      int cycle_size = 0;      int j = i;      while (!vis[j])      {        vis[j] = true;         // move to next node        j = arrPos.get(j).get(1);        cycle_size++;      }       // Update answer by adding current cycle.      ans += (cycle_size - 1);    }     // Return result    return ans;  }   // method returns minimum number of swap to make  // array B same as array A  static int minSwapToMakeArraySame(int a[], int b[], int n)  {     // map to store position of elements in array B    // we basically store element to index mapping.    Map mp      = new HashMap();     for (int i = 0; i < n; i++)    {      mp.put(b[i], i);    }     // now we're storing position of array A elements    // in array B.    for (int i = 0; i < n; i++)      b[i] = mp.get(a[i]);     /* We can uncomment this section to print modified        b array        for (int i = 0; i < N; i++)            cout << b[i] << " ";        cout << endl; */     // returning minimum swap for sorting in modified    // array B as final answer    return minSwapsToSort(b, n);  }   // Driver code  public static void main (String[] args)  {    int a[] = {3, 6, 4, 8};    int b[] = {4, 6, 8, 3};    int n = a.length;     System.out.println( minSwapToMakeArraySame(a, b, n));  }} // This code is contributed by avanitrachhadiya2155

Python3

 # Python3 program to make# an array same to another# using minimum number of swap # Function returns the minimum# number of swaps required to# sort the array# This method is taken from below post# https: // www.geeksforgeeks.org/# minimum-number-swaps-required-sort-array/def minSwapsToSort(arr, n):     # Create an array of pairs    # where first element is    # array element and second    # element is position of    # first element    arrPos = [[0 for x in range(2)]                 for y in range(n)]         for i in range(n):           arrPos[i] = arr[i]        arrPos[i] = i     # Sort the array by array    # element values to get right    # position of every element    # as second element of pair.    arrPos.sort()     # To keep track of visited    # elements. Initialize all    # elements as not visited    # or false.    vis = [False] * (n)     # Initialize result    ans = 0     # Traverse array elements    for i in range(n):             # Already swapped and corrected or        # already present at correct pos        if (vis[i] or arrPos[i] == i):            continue         # Find out the number of  node in        # this cycle and add in ans        cycle_size = 0        j = i                 while (not vis[j]):                   vis[j] = 1             # Move to next node            j = arrPos[j]            cycle_size+= 1                # Update answer by        # adding current cycle.        ans += (cycle_size - 1)      # Return result    return ans # Method returns minimum# number of swap to mak# array B same as array Adef minSwapToMakeArraySame(a, b, n):             # map to store position    # of elements in array B    # we basically store    # element to index mapping.    mp = {}    for i in range(n):        mp[b[i]] = i     # now we're storing position    # of array A elements    # in array B.    for i in range(n):        b[i] = mp[a[i]]     # Returning minimum swap    # for sorting in modified    # array B as final answer    return minSwapsToSort(b, n) # Driver codeif __name__ == "__main__":     a = [3, 6, 4, 8]    b = [4, 6, 8, 3]    n = len(a)    print(minSwapToMakeArraySame(a, b, n)) # This code is contributed by Chitranayal

C#

 // C# program to make an array same to another// using minimum number of swapusing System;using System.Collections.Generic;using System.Linq; // Function returns the minimum number of swaps// required to sort the array// This method is taken from below post// https://www.geeksforgeeks.org/minimum-number-swaps-required-sort-array/public class GFG{  static int minSwapsToSort(int[] arr, int n)  {     // Create an array of pairs where first    // element is array element and second element    // is position of first element       List> arrPos = new List>();    for (int i = 0; i < n; i++)    {      arrPos.Add(new List(){arr[i],i});    }     // Sort the array by array element values to    // get right position of every element as second    // element of pair.    arrPos=arrPos.OrderBy(x => x).ToList();     // To keep track of visited elements. Initialize    // all elements as not visited or false.    bool[] vis = new bool[n];    Array.Fill(vis,false);     // Initialize result    int ans = 0;     // Traverse array elements    for (int i = 0; i < n; i++)    {       // already swapped and corrected or      // already present at correct pos      if (vis[i] || arrPos[i] == i)        continue;       // find out the number of  node in      // this cycle and add in ans      int cycle_size = 0;      int j = i;       while (!vis[j])      {        vis[j] = true;         // move to next node        j = arrPos[j];        cycle_size++;      }       // Update answer by adding current cycle.      ans += (cycle_size - 1);    }    // Return result    return ans;  }   // method returns minimum number of swap to make  // array B same as array A  static int minSwapToMakeArraySame(int[] a, int[] b, int n)  {    Dictionary mp = new Dictionary();    for (int i = 0; i < n; i++)    {      mp.Add(b[i],i);    }    // now we're storing position of array A elements    // in array B.    for (int i = 0; i < n; i++)    {      b[i] = mp[a[i]];    }     /* We can uncomment this section to print modified        b array        for (int i = 0; i < N; i++)            cout << b[i] << " ";        cout << endl; */     // returning minimum swap for sorting in modified    // array B as final answer    return minSwapsToSort(b, n);  }   // Driver code  static public void Main (){     int[] a = {3, 6, 4, 8};    int[] b = {4, 6, 8, 3};    int n = a.Length;     Console.WriteLine( minSwapToMakeArraySame(a, b, n));   }} // This code is contributed by rag2127

Javascript



Output:

2

This article is contributed by Utkarsh Trivedi. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.