Related Articles

# Minimum swaps to make two arrays identical

• Difficulty Level : Hard
• Last Updated : 24 Jun, 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<``int``, ``int``> 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<``bool``> 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 A``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<``int``, ``int``> 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; */` `    ``// returing minimum swap for sorting in modified``    ``// array B as final answer``    ``return` `minSwapsToSort(b, n);``}` `//    Driver code to test above methods``int` `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 swap``import` `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; */` `    ``// returing 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][``0``] ``=` `arr[i]``        ``arrPos[i][``1``] ``=` `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][``1``] ``=``=` `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][``1``]``            ``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 A``def` `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]]` `    ``# Returing minimum swap``    ``# for sorting in modified``    ``# array B as final answer``    ``return` `minSwapsToSort(b, n)` `# Driver code``if` `__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 swap``using` `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<``int``>(){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<``int``,``int``> mp = ``new` `Dictionary<``int``,``int``>();``    ``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; */` `    ``// returing 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.