Absolute difference between given permutations of N natural numbers

• Last Updated : 14 Jan, 2022

Given two permutations arrays arr[] and brr[] of the first N Natural Numbers from 1 to N, the task is to find the absolute difference between the positions of their order in lexicographical order.

Examples:

Input: arr[] = {1, 3, 2}, brr[] = {3, 1, 2}
Output: 3
Explanation:
There are 6 possible permutations of the first N(= 3) natural numbers. They are {{1, 2, 3}, {1, 3, 2}, {2, 1, 3}, {2, 3, 1}, {3, 1, 2}, {3, 2, 1}}. The position of arr[] is 2 and the position of brr[] is 5. Therefore, the answer is |2 – 5| = 3.

Input: arr[] = {1, 3, 2, 4}, brr[] = {1, 3, 2, 4}
Output: 0

Approach: The given problem can be solved by generating the next permutation of the first N natural numbers using the function Next Permutation STL. The idea is to consider arr[] as the base permutation and perform the next_permutation() until arr[] is not equal to brr[]. After this step, the count of steps required to convert arr[] to brr[] is the resultant value of the absolute difference between their positions in lexicographical order.

Below is the implementation of the above approach:

C++

 // C++ program for the above approach #include using namespace std;   // Function to find the distance between // two permutations array arr[] and brr[] // in lexicographical order int permutationDiff(vector arr,                     vector brr) {       // Check if both permutations are     // already equal or not     if (arr == brr) {         return 0;     }       // Stores the distance between the     // two permutations arr[] and brr[]     int count = 0;       while (arr != brr) {           // Increment the count         count++;           // call next_permutation         next_permutation(brr.begin(),                          brr.end());     }       // Return the total count     return count; }   // Driver Code int main() {     vector arr = { 1, 3, 2 };     vector brr = { 3, 1, 2 };       cout << permutationDiff(arr, brr);       return 0; }

Java

 // Java program for the above approach import java.util.*; public class GFG {     // Utility function to find next permutation public static void next_permutation(int nums[]) {     int mark = -1;     for (int i = nums.length - 1; i > 0; i--) {         if (nums[i] > nums[i - 1]) {             mark = i - 1;             break;         }     }     if (mark == -1) {         reverse(nums, 0, nums.length - 1);         return;     }     int idx = nums.length-1;     for (int i = nums.length-1; i >= mark+1; i--) {         if (nums[i] > nums[mark]) {             idx = i;             break;         }     }     swap(nums, mark, idx);     reverse(nums, mark + 1, nums.length - 1); }   // Utility function to swap two elements in array public static void swap(int nums[], int i, int j) {     int t = nums[i];     nums[i] = nums[j];     nums[j] = t; } // Utility function to reverse the array in a range public static void reverse(int nums[], int i, int j) {     while (i < j) {         swap(nums, i, j);         i++;         j--;     } } // Function to find the distance between // two permutations array arr[] and brr[] // in lexicographical order public static int permutationDiff(int arr[], int brr[]) {     // Check if both permutations are     // already equal or not     if (Arrays.equals(arr, brr)) {         return 0;     }     // Stores the distance between the     // two permutations arr[] and brr[]     int count = 0, flag = 0;     while(!Arrays.equals(arr, brr))     {         // Increment the count         count++;         // call next_permutation         next_permutation(brr);     }     // Return the total count     return count; }   // Driver Code public static void main(String args[]) {     int []arr = { 1, 3, 2 };     int []brr = { 3, 1, 2 };           System.out.println(permutationDiff(arr, brr));     } } // This code is contributed by Samim Hossain Mondal

Python3

 # Python program for the above approach   # Function for next permutation def next_permutation(arr):       # find the length of the array     n = len(arr)       # start from the right most digit and find the first     # digit that is smaller than the digit next to it.     k = n - 2     while k >= 0:         if arr[k] < arr[k + 1]:             break         k -= 1       # reverse the list if the digit that is smaller than the     # digit next to it is not found.     if k < 0:         arr = arr[::-1]     else:           # find the first greatest element than arr[k] from the         # end of the list         for l in range(n - 1, k, -1):             if arr[l] > arr[k]:                 break           # swap the elements at arr[k] and arr[l         arr[l], arr[k] = arr[k], arr[l]           # reverse the list from k + 1 to the end to find the         # most nearest greater number to the given input number         arr[k + 1:] = reversed(arr[k + 1:])       return arr       # Function to find the distance between     # two permutations array arr[] and brr[]     # in lexicographical order     def permutationDiff(arr,                     brr):       # Check if both permutations are     # already equal or not     if (arr == brr):         return 0       # Stores the distance between the     # two permutations arr[] and brr[]     count = 0       while (arr != brr):           # Increment the count         count = count+1           # call next_permutation         brr = next_permutation(brr)       # Return the total count     return count     arr = [1, 3, 2] brr = [3, 1, 2]   print(permutationDiff(arr, brr))   # This code is contributed by Potta Lokesh

C#

 // C# program for the above approach using System; using System.Linq;   class GFG { // Utility function to find next permutation static void next_permutation(int []nums) {     int mark = -1;     for (int i = nums.Length - 1; i > 0; i--) {         if (nums[i] > nums[i - 1]) {             mark = i - 1;             break;         }     }     if (mark == -1) {         reverse(nums, 0, nums.Length - 1);         return;     }     int idx = nums.Length-1;     for (int i = nums.Length-1; i >= mark+1; i--) {         if (nums[i] > nums[mark]) {             idx = i;             break;         }     }     swap(nums, mark, idx);     reverse(nums, mark + 1, nums.Length - 1); }   // Utility function to swap two elements in array static void swap(int []nums, int i, int j) {     int t = nums[i];     nums[i] = nums[j];     nums[j] = t; } // Utility function to reverse the array in a range public static void reverse(int []nums, int i, int j) {     while (i < j) {         swap(nums, i, j);         i++;         j--;     } } // Function to find the distance between // two permutations array arr[] and brr[] // in lexicographical order public static int permutationDiff(int []arr, int []brr) {     // Check if both permutations are     // already equal or not     if (arr.SequenceEqual(brr)) {         return 0;     }     // Stores the distance between the     // two permutations arr[] and brr[]     int count = 0, flag = 0;     while(!arr.SequenceEqual(brr))     {         // Increment the count         count++;         // call next_permutation         next_permutation(brr);     }     // Return the total count     return count; }   // Driver Code public static void Main() {     int []arr = { 1, 3, 2 };     int []brr = { 3, 1, 2 };           Console.Write(permutationDiff(arr, brr));     } } // This code is contributed by Samim Hossain Mondal

Javascript



Output:

3

Time Complexity: O(N2)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up
Recommended Articles
Page :