# Shortest path to traverse all the elements of a circular array in increasing order

• Difficulty Level : Medium
• Last Updated : 16 Sep, 2022

There are N distinct integers arranged on a circle. The distance between any two adjacent numbers is 1. The task is to travel on this circle starting with the smallest number, then moving to the second smallest, third smallest, and so on until the largest number and print the minimum travel distance.

Examples:

Input: arr[] = {3, 6, 5, 1, 2, 4}
Output:
1 -> 2 (Left to right)
2 -> 3 (Left to right)
3 -> 4 (Right to left)
4 -> 5 (Left to right or right to left)
5 -> 6 (Right to left)

Input: arr[] = {14, 16, 8, 17, 12, 10, 4, 13, 11, 20}
Output: 27

Approach: If we want to travel between two elements with indices i and j, we have two possible paths, one of length |i – j| and the other of length n – |i – j| and we will take the one with the minimum distance.

Initially, we build an array of pairs of (element, index) and we sort it in increasing order of the elements. Then we can take every two consecutive pairs and find the shortest way to travel between these two elements.

Below is the implementation of the above approach:

## CPP

 `#include ``#define mod 1000000007``using` `namespace` `std;` `// Function to return the minimum distance``int` `min_distance(``int` `n, vector<``int``> arr)``{` `    ``// Declare a Pair[] array of size n``    ``vector> val(n);` `    ``// Store all the (element, index) pairs``    ``for` `( ``int` `i = 0; i < n; i++)``        ``val[i] = {arr[i], i};` `    ``// Sort the pairs in ascending order of the value``    ``sort(val.begin(), val.end());` `    ``int` `min_dist = 0;``    ``for` `(``int` `i = 1; i < n; i++)``    ``{` `        ``// Choose the minimum distance path``        ``// of the two available``        ``min_dist += min(``abs``(val[i].second - val[i - 1].second),``                    ``n - ``abs``(val[i].second - val[i - 1].second));``    ``}` `    ``return` `min_dist;``}`  `// Driver Code``int` `main()``{``    ``vector<``int``> arr = {3, 6, 5, 1, 2, 4};``    ``int` `n = arr.size();``    ``cout << (min_distance(n, arr));``}` `// This code is contributed by mohit kumar 29`

## Java

 `// Java implementation of the approach``import` `java.util.*;` `class` `GFG {` `    ``// Function to return the minimum distance``    ``static` `int` `min_distance(``int` `n, ``int``[] arr)``    ``{` `        ``// Declare a Pair[] array of size n``        ``Pair[] val = ``new` `Pair[n];` `        ``// Store all the (element, index) pairs``        ``for` `(``int` `i = ``0``; i < n; i++)``            ``val[i] = ``new` `Pair(arr[i], i);` `        ``// Sort the pairs in ascending order of the value``        ``Arrays.sort(val, com);` `        ``int` `min_dist = ``0``;``        ``for` `(``int` `i = ``1``; i < n; i++) {` `            ``// Choose the minimum distance path``            ``// of the two available``            ``min_dist``                ``+= Math.min(Math.abs(val[i].y - val[i - ``1``].y),``                            ``n - Math.abs(val[i].y - val[i - ``1``].y));``        ``}` `        ``return` `min_dist;``    ``}` `    ``// Comparator to be used in the``    ``// sorting of pairs based on the values``    ``static` `final` `Comparator com = ``new` `Comparator() {``        ``public` `int` `compare(Pair a, Pair b)``        ``{``            ``if` `(Integer.compare(a.x, b.x) != ``0``)``                ``return` `Integer.compare(a.x, b.x);``            ``else``                ``return` `Integer.compare(a.y, b.y);``        ``}``    ``};` `    ``// Class to represent a pair``    ``static` `class` `Pair {``        ``int` `x, y;``        ``Pair(``int` `p, ``int` `q)``        ``{``            ``x = p;``            ``y = q;``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[] arr = ``new` `int``[] { ``3``, ``6``, ``5``, ``1``, ``2``, ``4` `};``        ``int` `n = arr.length;` `        ``System.out.println(min_distance(n, arr));``    ``}``}`

## Python

 `# Python implementation of the approach` `# Function to return the minimum distance``def` `min_distance(n, arr):``    ` `    ``# Declare a Pair[] array of size n``    ``val ``=` `[``None``] ``*` `n` `    ``# Store all the (element, index) pairs``    ``for` `i ``in` `range``(``0``, n):``        ``val[i] ``=` `(arr[i], i)` `    ``# Sort the pairs in ascending order of the value``    ``val.sort()` `    ``min_dist ``=` `0``    ``for` `i ``in` `range``(``1``, n):` `        ``# Choose the minimum distance path``        ``# of the two available``        ``min_dist ``+``=` `min``(``abs``(val[i][``1``] ``-` `val[i ``-` `1``][``1``]),``                        ``n ``-` `abs``(val[i][``1``] ``-` `val[i ``-` `1``][``1``]))``        ` `    ``return` `min_dist` `# Driver code``if` `__name__ ``=``=` `"__main__"``:``    ` `    ``arr ``=` `[``3``, ``6``, ``5``, ``1``, ``2``, ``4``]``    ``n ``=` `len``(arr)` `    ``print``(min_distance(n, arr))` `# This code is contributed by Rituraj Jain`

## Javascript

 ``

Output

`8`

Complexity Analysis:

• Time Complexity: O(n * log(n))
• Auxiliary Space: O(n)

My Personal Notes arrow_drop_up