给定两个具有相同值但顺序不同的数组，我们需要使用最少的交换次数使第二个数组与第一个数组相同。
例子：
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}这个问题可以通过修改数组B来解决。我们将数组A的元素的索引保存在数组B中，即如果数组A的第i个元素在数组B中的第j个位置，那么我们将使arrB [i] = j
对于上面给出的示例，修改后的数组B将为arrB = {3，1，0，2}。此修改后的数组表示数组B中元素A的分布，我们的目标是以最少的交换次数对此修改后的数组进行排序，因为排序后仅数组B元素将与数组A元素对齐。
现在可以通过将问题可视化为图形来找到用于对数组进行排序的最小交换次数，该问题已在上一篇文章中进行了解释。
因此，我们将这些交换数计入修改后的数组中，这将是我们的最终答案。
请参阅下面的代码以更好地理解。
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 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 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 ChitranayalC#
// 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(){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 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; */
// 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 输出：
2