Minimum swaps to make two arrays consisting unique elements identical

Given two arrays that have the same values but in a different order and having no duplicate elements in it, 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
Explanation: 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 <bits/stdc++.h>
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; */

    // returning 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<ArrayList<Integer>> arrPos = new ArrayList<ArrayList<Integer>>();
    for (int i = 0; i < n; i++)
    {
      arrPos.add(new ArrayList<Integer>(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<ArrayList<Integer>>() {
      @Override
      public int compare(ArrayList<Integer> o1, ArrayList<Integer> 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<Integer, Integer> mp
      = new HashMap<Integer, Integer>();

    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][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 make
# 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]]

    # Returning 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<List<int>> arrPos = new List<List<int>>();
    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[0]).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][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[j][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)
  {
    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; */

    // 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

<script>

// JavaScript 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/
*/
function minSwapsToSort(arr,n)
{
    // Create an array of pairs where first
    // element is array element and second element
    // is position of first element
    let arrPos = [];
    for (let i = 0; i < n; i++)
    {
      arrPos.push([arr[i],i]);
    }

    // Sort the array by array element values to
    // get right position of every element as second
    // element of pair.
    arrPos.sort(function(a,b){return a[0]-b[0];});

    // To keep track of visited elements. Initialize
    // all elements as not visited or false.
    let vis = new Array(n);
    for(let i=0;i<n;i++)
    {
        vis[i]=false;
    }

    // Initialize result
    let ans = 0;

    // Traverse array elements
    for (let i = 0; i < n; i++)
    {

      // already swapped and corrected or
      // already present at correct pos
      if (vis[i] || arrPos[i][1] == i)
        continue;

      // find out the number of  node in
      // this cycle and add in ans
      let cycle_size = 0;
      let j = i;
      while (!vis[j])
      {
        vis[j] = true;

        // move to next node
        j = arrPos[j][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
function minSwapToMakeArraySame(a,b,n)
{
    // map to store position of elements in array B
    // we basically store element to index mapping.
    let mp = new Map();

    for (let i = 0; i < n; i++)
    {
      mp.set(b[i], i);
    }

    // now we're storing position of array A elements
    // in array B.
    for (let 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
let a=[3, 6, 4, 8];
let b=[4, 6, 8, 3];
let n = a.length;
document.write( minSwapToMakeArraySame(a, b, n));

// This code is contributed by ab2127

</script>

Output:  

2

Time Complexity: O(n log n)
Auxiliary Space: O(n)

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.