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 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 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 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 /* -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)
Recommended Articles