Number of Transpositions in a Permutation

01 Jun, 2022
Permutation A permutation is an arrangement of elements. A permutation of n elements can be represented by an arrangement of the numbers 1, 2, ...n in some order. Eg. 5, 1, 4, 2, 3.Cycle notation A permutation can be represented as a composition of permutation cycles. A permutation cycle is a set of elements in a permutation that trade places with one another. For e.g.  
P = { 5, 1, 4, 2, 3 }: Here, 5 goes to 1, 1 goes to 2 and so on (according to their indices position): 5 -> 1 1 -> 2 2 -> 4 4 -> 3 3 -> 5 Thus it can be represented as a single cycle: (5, 1, 2, 4, 3).Now consider the permutation: {5, 1, 4, 3, 2}. Here 5 -> 1 1 -> 2 2 -> 5 this closes 1 cycle. The other cycle is 4 -> 3 3 -> 4 In cycle notation it will be represented as (5, 1, 2) (4, 3). 
Transpositions Now all cycles can be decomposed into a composition of 2 cycles (transpositions). The number of transpositions in a permutation is important as it gives the minimum number of 2 element swaps required to get this particular arrangement from the identity arrangement: 1, 2, 3, ... n. The parity of the number of such 2 cycles represents whether the permutation is even or odd. For e.g.  
The cycle (5, 1, 2, 4, 3) can be written as (5, 3)(5, 4)(5, 2)(5, 1). 4 transpositions (even). Similarly, (5, 1, 2) -> (5, 2)(5, 1) (5, 1, 2)(4, 3) -> (5, 2)(5, 1)(4, 3). 3 transpositions (odd). It is clear from the examples that the number of transpositions from a cycle = length of the cycle – 1.  
Problem Given a permutation of n numbers P1, P2, P3, ... Pn. Calculate the number of transpositions in it. Example:  
Input: 5 1 4 3 2
Output: 3 
Approach: The permutation can be easily represented as a directed graph where the number of connected components gives the number of cycles. And (the size of each component – 1) gives the number of transpositions from that cycle.Example Permutation : {5, 1, 4, 3, 2} -> (5, 1, 2)(4, 3) 
Below is the implementation of the above approach.  
C++
Java
Python3
C#
Javascript
// CPP Program to find the number of// transpositions in a permutation#include <bits/stdc++.h>using namespace std; #define N 1000001 int visited[N]; // This array stores which element goes to which positionint goesTo[N]; // For eg. in { 5, 1, 4, 3, 2 }// goesTo[1] = 2// goesTo[2] = 5// goesTo[3] = 4// goesTo[4] = 3// goesTo[5] = 1 // This function returns the size of a component cycleint dfs(int i){    // If it is already visited    if (visited[i] == 1)        return 0;     visited[i] = 1;    int x = dfs(goesTo[i]);    return (x + 1);} // This function returns the number// of transpositions in the permutationint noOfTranspositions(int P[], int n){    // Initializing visited[] array    for (int i = 1; i <= n; i++)        visited[i] = 0;     // building the goesTo[] array    for (int i = 0; i < n; i++)        goesTo[P[i]] = i + 1;     int transpositions = 0;     for (int i = 1; i <= n; i++) {        if (visited[i] == 0) {            int ans = dfs(i);            transpositions += ans - 1;        }    }    return transpositions;} // Driver Codeint main(){    int permutation[] = { 5, 1, 4, 3, 2 };    int n = sizeof(permutation) / sizeof(permutation[0]);     cout << noOfTranspositions(permutation, n);    return 0;}
// Java Program to find the number of// transpositions in a permutationimport java.io.*; class GFG {         static int N = 1000001;         static int visited[] = new int[N];         // This array stores which element    // goes to which position    static int goesTo[]= new int[N];         // For eg. in { 5, 1, 4, 3, 2 }    // goesTo[1] = 2    // goesTo[2] = 5    // goesTo[3] = 4    // goesTo[4] = 3    // goesTo[5] = 1         // This function returns the size    // of a component cycle    static int dfs(int i)    {                 // If it is already visited        if (visited[i] == 1)            return 0;             visited[i] = 1;        int x = dfs(goesTo[i]);        return (x + 1);    }         // This function returns the number    // of transpositions in the    // permutation    static int noOfTranspositions(int P[],                                    int n)    {        // Initializing visited[] array        for (int i = 1; i <= n; i++)            visited[i] = 0;             // building the goesTo[] array        for (int i = 0; i < n; i++)            goesTo[P[i]] = i + 1;             int transpositions = 0;             for (int i = 1; i <= n; i++) {            if (visited[i] == 0) {                int ans = dfs(i);                transpositions += ans - 1;            }        }        return transpositions;    }         // Driver Code    public static void main (String[] args)    {        int permutation[] = { 5, 1, 4, 3, 2 };        int n = permutation.length ;         System.out.println(           noOfTranspositions(permutation, n));    }} // This code is contributed by anuj_67.
# Python Program to find the number of# transpositions in a permutationN = 1000001 visited = [0] * N; # This array stores which element goes to which positiongoesTo = [0] * N; # For eg. in { 5, 1, 4, 3, 2 }# goesTo[1] = 2# goesTo[2] = 5# goesTo[3] = 4# goesTo[4] = 3# goesTo[5] = 1 # This function returns the size of a component cycledef dfs(i) :     # If it is already visited    if (visited[i] == 1) :        return 0;     visited[i] = 1;    x = dfs(goesTo[i]);    return (x + 1); # This function returns the number# of transpositions in the permutationdef noOfTranspositions(P, n) :     # Initializing visited[] array    for i in range(1, n + 1) :        visited[i] = 0;     # building the goesTo[] array    for i in range(n) :        goesTo[P[i]] = i + 1;     transpositions = 0;     for i in range(1, n + 1) :        if (visited[i] == 0) :            ans = dfs(i);            transpositions += ans - 1;     return transpositions; # Driver Codeif __name__ == "__main__" :     permutation = [ 5, 1, 4, 3, 2 ];    n = len(permutation);     print(noOfTranspositions(permutation, n)); # This code is contributed by AnkitRai01
// C# Program to find the number of// transpositions in a permutationusing System; class GFG {         static int N = 1000001;         static int []visited = new int[N];         // This array stores which element    // goes to which position    static int []goesTo= new int[N];         // For eg. in { 5, 1, 4, 3, 2 }    // goesTo[1] = 2    // goesTo[2] = 5    // goesTo[3] = 4    // goesTo[4] = 3    // goesTo[5] = 1         // This function returns the size    // of a component cycle    static int dfs(int i)    {                 // If it is already visited        if (visited[i] == 1)            return 0;             visited[i] = 1;        int x = dfs(goesTo[i]);        return (x + 1);    }         // This function returns the number    // of transpositions in the    // permutation    static int noOfTranspositions(int []P,                                    int n)    {        // Initializing visited[] array        for (int i = 1; i <= n; i++)            visited[i] = 0;             // building the goesTo[] array        for (int i = 0; i < n; i++)            goesTo[P[i]] = i + 1;             int transpositions = 0;             for (int i = 1; i <= n; i++) {            if (visited[i] == 0) {                int ans = dfs(i);                transpositions += ans - 1;            }        }        return transpositions;    }         // Driver Code    public static void Main ()    {        int []permutation = { 5, 1, 4, 3, 2 };        int n = permutation.Length ;         Console.WriteLine(        noOfTranspositions(permutation, n));    }} // This code is contributed by anuj_67.
<script> // Javascript Program to find the number of// transpositions in a permutation let N = 1000001var visited = new Array(N); // This array stores which element goes to which positionvar goesTo = new Array(N); // For eg. in { 5, 1, 4, 3, 2 }// goesTo[1] = 2// goesTo[2] = 5// goesTo[3] = 4// goesTo[4] = 3// goesTo[5] = 1 // This function returns the size of a component cyclefunction dfs( i){    // If it is already visited    if (visited[i] == 1)        return 0;     visited[i] = 1;    let x = dfs(goesTo[i]);    return (x + 1);} // This function returns the number// of transpositions in the permutationfunction noOfTranspositions( P, n){    // Initializing visited[] array    for (let i = 1; i <= n; i++)        visited[i] = 0;     // building the goesTo[] array    for (let i = 0; i < n; i++)        goesTo[P[i]] = i + 1;     let transpositions = 0;     for (let i = 1; i <= n; i++) {        if (visited[i] == 0) {            let ans = dfs(i);            transpositions += ans - 1;        }    }    return transpositions;} // Driver Code let permutation = [ 5, 1, 4, 3, 2 ];let n = permutation.length; document.write(noOfTranspositions(permutation, n)); </script>
Output:  
3
Time Complexity : O(n) Auxiliary space : O(n) 
vt_m
ankthon
jana_sayantan
surinderdawra388
DFS
Competitive Programming
Graph
Mathematical
Mathematical
DFS
Graph
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Modulo 10^9+7 (1000000007)
Prefix Sum Array - Implementation and Applications in Competitive Programming
Bits manipulation (Important tactics)
What is Competitive Programming and How to Prepare for It?
Count of strings whose prefix match with the given string to a given length k
Breadth First Search or BFS for a Graph
Depth First Search or DFS for a Graph
Dijkstra's shortest path algorithm | Greedy Algo-7
Prim’s Minimum Spanning Tree (MST) | Greedy Algo-5
Graph and its representations