Skip to content
Related Articles

Related Articles

Save Article
Improve Article
Save Article
Like Article

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

  • Difficulty Level : Medium
  • Last Updated : 02 Jun, 2021

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 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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 <bits/stdc++.h>
#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<pair<int,int>> 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<Pair> com = new Comparator<Pair>() {
        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




<script>
 
// JavaScript implementation of the approach
 
// Function to return the minimum distance
function min_distance(n,arr)
{
    // Declare a Pair[] array of size n
        let val = new Array(n);
      
        // Store all the (element, index) pairs
        for (let i = 0; i < n; i++)
            val[i] = [arr[i], i];
  
        // Sort the pairs in ascending order of the value
        val.sort(function(a,b){return a[0]-b[0];});
  
        let min_dist = 0;
        for (let i = 1; i < n; i++) {
  
            // Choose the minimum distance path
            // of the two available
            min_dist
                += Math.min(Math.abs(val[i][1] - val[i - 1][1]),
                         n - Math.abs(val[i][1] - val[i - 1][1]));
        }
  
        return min_dist;
}
 
// Driver code
let arr=[3, 6, 5, 1, 2, 4];
let n=arr.length;
document.write(min_distance(n, arr))
 
// This code is contributed by patel2127
 
</script>
Output: 
8

 

Time Complexity: O(n * log(n))

Auxiliary Space: O(n)




My Personal Notes arrow_drop_up
Recommended Articles
Page :