Minimum number of swaps required for arranging pairs adjacent to each other

30 Jul, 2021
There are n-pairs and therefore 2n people. everyone has one unique number ranging from 1 to 2n. All these 2n persons are arranged in random fashion in an Array of size 2n. We are also given who is partner of whom. Find the minimum number of swaps required to arrange these pairs such that all pairs become adjacent to each other.Example: 
Input:
n = 3  
pairs[] = {1->3, 2->6, 4->5}  // 1 is partner of 3 and so on
arr[] = {3, 5, 6, 4, 1, 2}

Output: 2
We can get {3, 1, 5, 4, 6, 2} by swapping 5 & 6, and 6 & 1
We strongly recommend you to minimize your browser and try this yourself first.The idea is to start from first and second elements and recur for remaining elements. Below are detailed steps/ 
1) If first and second elements are pair, then simply recur 
   for remaining n-1 pairs and return the value returned by 
   recursive call.

2) If first and second are NOT pair, then there are two ways to 
   arrange. So try both of them return the minimum of two.
   a) Swap second with pair of first and recur for n-1 elements. 
      Let the value returned by recursive call be 'a'.
   b) Revert the changes made by previous step.
   c) Swap first with pair of second and recur for n-1 elements. 
      Let the value returned by recursive call be 'b'.
   d) Revert the changes made by previous step before returning
      control to parent call.
   e) Return 1 + min(a, b)
Example: Below is the implementation of above algorithm. 
C++
Java
Python3
C#
Javascript
// C++ program to find minimum number of swaps required so that// all pairs become adjacent.#include<bits/stdc++.h>using namespace std; // This function updates indexes of elements 'a' and 'b'void updateindex(int index[], int a, int ai, int b, int bi){    index[a] = ai;    index[b] = bi;} // This function returns minimum number of swaps required to arrange// all elements of arr[i..n] become arrangedint minSwapsUtil(int arr[], int pairs[], int index[], int i, int n){    // If all pairs processed so no swapping needed return 0    if (i > n) return 0;     // If current pair is valid so DO NOT DISTURB this pair    // and move ahead.    if (pairs[arr[i]] == arr[i+1])         return minSwapsUtil(arr, pairs, index, i+2, n);     // If we reach here, then arr[i] and arr[i+1] don't form a pair     // Swap pair of arr[i] with arr[i+1] and recursively compute    // minimum swap required if this move is made.    int one = arr[i+1];    int indextwo = i+1;    int indexone = index[pairs[arr[i]]];    int two = arr[index[pairs[arr[i]]]];    swap(arr[i+1], arr[indexone]);    updateindex(index, one, indexone, two, indextwo);    int a = minSwapsUtil(arr, pairs, index, i+2, n);     // Backtrack to previous configuration. Also restore the    // previous indices, of one and two    swap(arr[i+1], arr[indexone]);    updateindex(index, one, indextwo, two, indexone);    one = arr[i], indexone = index[pairs[arr[i+1]]];     // Now swap arr[i] with pair of arr[i+1] and recursively    // compute minimum swaps required for the subproblem    // after this move    two = arr[index[pairs[arr[i+1]]]], indextwo = i;    swap(arr[i], arr[indexone]);    updateindex(index, one, indexone, two, indextwo);    int b = minSwapsUtil(arr, pairs, index, i+2, n);     // Backtrack to previous configuration.  Also restore    // the previous indices, of one and two    swap(arr[i], arr[indexone]);    updateindex(index, one, indextwo, two, indexone);     // Return minimum of two cases    return 1 + min(a, b);} // Returns minimum swaps requiredint minSwaps(int n, int pairs[], int arr[]){    int index[2*n + 1]; // To store indices of array elements     // Store index of each element in array index    for (int i = 1; i <= 2*n; i++)        index[arr[i]] = i;     // Call the recursive function    return minSwapsUtil(arr, pairs, index, 1, 2*n);} // Driver programint main(){    // For simplicity, it is assumed that arr[0] is    // not used.  The elements from index 1 to n are    // only valid elements    int arr[] = {0, 3, 5, 6, 4, 1, 2};     // if (a, b) is pair than we have assigned elements    // in array such that pairs[a] = b and pairs[b] = a    int pairs[] = {0, 3, 6, 1, 5, 4, 2};    int m = sizeof(arr)/sizeof(arr[0]);     int n = m/2;  // Number of pairs n is half of total elements     // If there are n elements in array, then    // there are n pairs    cout << "Min swaps required is " << minSwaps(n, pairs, arr);    return 0;}
// Java program to find minimum number// of swaps required so that// all pairs become adjacent. class GFG {     // This function updates indexes// of elements 'a' and 'b'static void updateindex(int index[], int a,                     int ai, int b, int bi){    index[a] = ai;    index[b] = bi;} // This function returns minimum number// of swaps required to arrange// all elements of arr[i..n] become arrangedstatic int minSwapsUtil(int arr[], int pairs[],                     int index[], int i, int n){    // If all pairs processed so    // no swapping needed return 0    if (i > n)    return 0;     // If current pair is valid so    // DO NOT DISTURB this pair    // and move ahead.    if (pairs[arr[i]] == arr[i + 1])    return minSwapsUtil(arr, pairs, index, i + 2, n);     // If we reach here, then arr[i] and    // arr[i+1] don't form a pair     // Swap pair of arr[i] with arr[i+1]    // and recursively compute minimum swap    // required if this move is made.    int one = arr[i + 1];    int indextwo = i + 1;    int indexone = index[pairs[arr[i]]];    int two = arr[index[pairs[arr[i]]]];    arr[i + 1] = arr[i + 1] ^ arr[indexone] ^                (arr[indexone] = arr[i + 1]);    updateindex(index, one, indexone, two, indextwo);    int a = minSwapsUtil(arr, pairs, index, i + 2, n);     // Backtrack to previous configuration.    // Also restore the previous    // indices, of one and two    arr[i + 1] = arr[i + 1] ^ arr[indexone] ^                (arr[indexone] = arr[i + 1]);    updateindex(index, one, indextwo, two, indexone);    one = arr[i];    indexone = index[pairs[arr[i + 1]]];     // Now swap arr[i] with pair of arr[i+1]    // and recursively compute minimum swaps    // required for the subproblem    // after this move    two = arr[index[pairs[arr[i + 1]]]];    indextwo = i;    arr[i] = arr[i] ^ arr[indexone] ^ (arr[indexone] = arr[i]);    updateindex(index, one, indexone, two, indextwo);    int b = minSwapsUtil(arr, pairs, index, i + 2, n);     // Backtrack to previous configuration. Also restore    // the previous indices, of one and two    arr[i] = arr[i] ^ arr[indexone] ^ (arr[indexone] = arr[i]);    updateindex(index, one, indextwo, two, indexone);     // Return minimum of two cases    return 1 + Math.min(a, b);} // Returns minimum swaps requiredstatic int minSwaps(int n, int pairs[], int arr[]){    // To store indices of array elements    int index[] = new int[2 * n + 1];     // Store index of each element in array index    for (int i = 1; i <= 2 * n; i++)    index[arr[i]] = i;     // Call the recursive function    return minSwapsUtil(arr, pairs, index, 1, 2 * n);} // Driver codepublic static void main(String[] args) {         // For simplicity, it is assumed that arr[0] is    // not used. The elements from index 1 to n are    // only valid elements    int arr[] = {0, 3, 5, 6, 4, 1, 2};     // if (a, b) is pair than we have assigned elements    // in array such that pairs[a] = b and pairs[b] = a    int pairs[] = {0, 3, 6, 1, 5, 4, 2};    int m = pairs.length;     // Number of pairs n is half of total elements    int n = m / 2;     // If there are n elements in array, then    // there are n pairs    System.out.print("Min swaps required is " +                      minSwaps(n, pairs, arr));}} // This code is contributed by Anant Agarwal.
# Python program to find# minimum number of swaps# required so that# all pairs become adjacent. # This function updates# indexes of elements 'a' and 'b'def updateindex(index,a,ai,b,bi):     index[a] = ai    index[b] = bi   # This function returns minimum# number of swaps required to arrange# all elements of arr[i..n]# become arrangeddef minSwapsUtil(arr,pairs,index,i,n):     # If all pairs processed so    # no swapping needed return 0    if (i > n):        return 0      # If current pair is valid so    # DO NOT DISTURB this pair    # and move ahead.    if (pairs[arr[i]] == arr[i+1]):         return minSwapsUtil(arr, pairs, index, i+2, n)      # If we reach here, then arr[i]    # and arr[i+1] don't form a pair      # Swap pair of arr[i] with    # arr[i+1] and recursively compute    # minimum swap required    # if this move is made.    one = arr[i+1]    indextwo = i+1    indexone = index[pairs[arr[i]]]    two = arr[index[pairs[arr[i]]]]    arr[i+1],arr[indexone]=arr[indexone],arr[i+1]     updateindex(index, one, indexone, two, indextwo)     a = minSwapsUtil(arr, pairs, index, i+2, n)      # Backtrack to previous configuration.    # Also restore the    # previous indices,    # of one and two    arr[i+1],arr[indexone]=arr[indexone],arr[i+1]    updateindex(index, one, indextwo, two, indexone)    one = arr[i]    indexone = index[pairs[arr[i+1]]]      # Now swap arr[i] with pair    # of arr[i+1] and recursively    # compute minimum swaps    # required for the subproblem    # after this move    two = arr[index[pairs[arr[i+1]]]]    indextwo = i    arr[i],arr[indexone]=arr[indexone],arr[i]    updateindex(index, one, indexone, two, indextwo)    b = minSwapsUtil(arr, pairs, index, i+2, n)      # Backtrack to previous    # configuration.  Also restore    # 3 the previous indices,    # of one and two    arr[i],arr[indexone]=arr[indexone],arr[i]    updateindex(index, one, indextwo, two, indexone)      # Return minimum of two cases    return 1 + min(a, b) # Returns minimum swaps requireddef minSwaps(n,pairs,arr):     index=[] # To store indices of array elements    for i in range(2*n+1+1):        index.append(0)     # Store index of each    # element in array index    for i in range(1,2*n+1):        index[arr[i]] = i      # Call the recursive function    return minSwapsUtil(arr, pairs, index, 1, 2*n) # Driver code # For simplicity, it is# assumed that arr[0] is# not used.  The elements# from index 1 to n are# only valid elementsarr = [0, 3, 5, 6, 4, 1, 2]  # if (a, b) is pair than# we have assigned elements# in array such that# pairs[a] = b and pairs[b] = apairs= [0, 3, 6, 1, 5, 4, 2]m = len(pairs)  n = m//2  # Number of pairs n          # is half of total elements  # If there are n# elements in array, then# there are n pairsprint("Min swaps required is ",minSwaps(n, pairs, arr)) # This code is contributed# by Anant Agarwal.
// C# program to find minimum number// of swaps required so that// all pairs become adjacent.using System; class GFG {     // This function updates indexes    // of elements 'a' and 'b'    public static void updateindex(int[] index, int a,                             int ai, int b, int bi) {        index[a] = ai;        index[b] = bi;    }     // This function returns minimum number    // of swaps required to arrange    // all elements of arr[i..n] become arranged    public static int minSwapsUtil(int[] arr,     int[] pairs, int[] index, int i, int n) {                  // If all pairs processed so        // no swapping needed return 0        if (i > n) {            return 0;        }         // If current pair is valid so        // DO NOT DISTURB this pair        // and move ahead.        if (pairs[arr[i]] == arr[i + 1]) {            return minSwapsUtil(arr, pairs,                          index, i + 2, n);        }         // If we reach here, then arr[i] and        // arr[i+1] don't form a pair        // Swap pair of arr[i] with arr[i+1]        // and recursively compute minimum swap        // required if this move is made.        int one = arr[i + 1];                 int indextwo = i + 1;        int indexone = index[pairs[arr[i]]];        int two = arr[index[pairs[arr[i]]]];        arr[i + 1] = arr[i + 1] ^ arr[indexone] ^                     (arr[indexone] = arr[i + 1]);                              updateindex(index, one, indexone, two, indextwo);        int a = minSwapsUtil(arr, pairs, index, i + 2, n);         // Backtrack to previous configuration.        // Also restore the previous        // indices, of one and two        arr[i + 1] = arr[i + 1] ^ arr[indexone] ^                     (arr[indexone] = arr[i + 1]);                              updateindex(index, one, indextwo, two, indexone);        one = arr[i];        indexone = index[pairs[arr[i + 1]]];         // Now swap arr[i] with pair of arr[i+1]        // and recursively compute minimum swaps        // required for the subproblem        // after this move        two = arr[index[pairs[arr[i + 1]]]];        indextwo = i;        arr[i] = arr[i] ^ arr[indexone] ^                 (arr[indexone] = arr[i]);                          updateindex(index, one, indexone, two, indextwo);        int b = minSwapsUtil(arr, pairs, index, i + 2, n);         // Backtrack to previous configuration.        // Also restore the previous indices,        // of one and two        arr[i] = arr[i] ^ arr[indexone] ^                (arr[indexone] = arr[i]);                         updateindex(index, one, indextwo, two, indexone);         // Return minimum of two cases        return 1 + Math.Min(a, b);    }     // Returns minimum swaps required    public static int minSwaps(int n, int[] pairs, int[] arr) {        // To store indices of array elements        int[] index = new int[2 * n + 1];         // Store index of each element in array index        for (int i = 1; i <= 2 * n; i++) {            index[arr[i]] = i;        }         // Call the recursive function        return minSwapsUtil(arr, pairs, index, 1, 2 * n);    } // Driver codepublic static void Main(string[] args){     // For simplicity, it is assumed that arr[0] is    // not used. The elements from index 1 to n are    // only valid elements    int[] arr = new int[]    {        0,        3,        5,        6,        4,        1,        2    };     // if (a, b) is pair than we have assigned elements    // in array such that pairs[a] = b and pairs[b] = a    int[] pairs = new int[]    {        0,        3,        6,        1,        5,        4,        2    };         int m = pairs.Length;     // Number of pairs n is half of total elements    int n = m / 2;     // If there are n elements in array, then    // there are n pairs    Console.Write("Min swaps required is " +                   minSwaps(n, pairs, arr));}} // This code is contributed by Shrikant13
<script>// javascript program to find minimum number// of swaps required so that// all pairs become adjacent.    // This function updates indexes    // of elements 'a' and 'b'    function updateindex(index , a , ai , b , bi) {        index[a] = ai;        index[b] = bi;    }     // This function returns minimum number    // of swaps required to arrange    // all elements of arr[i..n] become arranged    function minSwapsUtil(arr , pairs , index , i , n) {        // If all pairs processed so        // no swapping needed return 0        if (i > n)            return 0;         // If current pair is valid so        // DO NOT DISTURB this pair        // and move ahead.        if (pairs[arr[i]] == arr[i + 1])            return minSwapsUtil(arr, pairs, index, i + 2, n);         // If we reach here, then arr[i] and        // arr[i+1] don't form a pair         // Swap pair of arr[i] with arr[i+1]        // and recursively compute minimum swap        // required if this move is made.        var one = arr[i + 1];        var indextwo = i + 1;        var indexone = index[pairs[arr[i]]];        var two = arr[index[pairs[arr[i]]]];        arr[i + 1] = arr[i + 1] ^ arr[indexone] ^ (arr[indexone] = arr[i + 1]);        updateindex(index, one, indexone, two, indextwo);        var a = minSwapsUtil(arr, pairs, index, i + 2, n);         // Backtrack to previous configuration.        // Also restore the previous        // indices, of one and two        arr[i + 1] = arr[i + 1] ^ arr[indexone] ^ (arr[indexone] = arr[i + 1]);        updateindex(index, one, indextwo, two, indexone);        one = arr[i];        indexone = index[pairs[arr[i + 1]]];         // Now swap arr[i] with pair of arr[i+1]        // and recursively compute minimum swaps        // required for the subproblem        // after this move        two = arr[index[pairs[arr[i + 1]]]];        indextwo = i;        arr[i] = arr[i] ^ arr[indexone] ^ (arr[indexone] = arr[i]);        updateindex(index, one, indexone, two, indextwo);        var b = minSwapsUtil(arr, pairs, index, i + 2, n);         // Backtrack to previous configuration. Also restore        // the previous indices, of one and two        arr[i] = arr[i] ^ arr[indexone] ^ (arr[indexone] = arr[i]);        updateindex(index, one, indextwo, two, indexone);         // Return minimum of two cases        return 1 + Math.min(a, b);    }     // Returns minimum swaps required    function minSwaps(n , pairs , arr) {        // To store indices of array elements        var index = Array(2 * n + 1).fill(0);         // Store index of each element in array index        for (i = 1; i <= 2 * n; i++)            index[arr[i]] = i;         // Call the recursive function        return minSwapsUtil(arr, pairs, index, 1, 2 * n);    }     // Driver code              // For simplicity, it is assumed that arr[0] is        // not used. The elements from index 1 to n are        // only valid elements        var arr = [ 0, 3, 5, 6, 4, 1, 2 ];         // if (a, b) is pair than we have assigned elements        // in array such that pairs[a] = b and pairs[b] = a        var pairs = [ 0, 3, 6, 1, 5, 4, 2 ];        var m = pairs.length;         // Number of pairs n is half of total elements        var n = m / 2;         // If there are n elements in array, then        // there are n pairs        document.write("Min swaps required is " + minSwaps(n, pairs, arr)); // This code contributed by aashish1995</script>
Output: 
Min swaps required is 2
Thanks to Gaurav Ahirwar for the above solution.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above 
shrikanth13
aashish1995
akshaysingh98088
sagar0719kumar
Google
Arrays
Google
Arrays
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.