# Calculate cost of visiting all array elements in increasing order

Given an array **arr[]** consisting of **N** integers, the task is to find the total cost of visiting all the array elements in ascending order, starting from **0**, if the cost of a move from index **i** to the index **j** is the absolute difference between **i** and **j**.

**Examples:**

Input:arr[ ] = { 4, 3, 2, 5, 1 }Output:11Explanation:

Jump from index 0 to index 4. Cost = abs(4 – 0) = 4.

Jump from index 4 to index 2. Cost = abs(4 – 2) = 2.

Jump from index 2 to index1. Cost = abs(2 – 1) = 1.

Jump from index 1 to index 0. Cost = abs(1 – 0) = 1.

Jump from index 0 to index 3. Cost = abs(0 – 3) = 3.

Therefore, the total cost of visiting all array elements in ascending order = (4 + 2 + 1 + 1 + 3 = 11).

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

**Approach: **The idea is to use the concept of sorting of the vector of pairs. Follow the steps below to solve the problem:

- Initialize a pair of
**vector<pair<int, int> >**, say**v,**to store the pairs of elements and their respective positions. - Traverse the array
**arr[]**and push the pair**{arr[i], i}**in the vector**v.** - Initialize two variables, say
**ans = 0**and**last = 0,**to store the total cost required and the index of the last visited element. - Sort the vector of pairs in ascending order.
- Traverse the vector
**v**and increment**ans**by**abs(v[i].second – last)**. Update**last**as**last = arr[i].second.** - After completing the above steps, print the answer obtained as
**ans.**

Below is the implementation of the above approach:

## C++

`// C++ implementation of the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to calculate total` `// cost of visiting array` `// elements in increasing order` `int` `calculateDistance(` `int` `arr[], ` `int` `N)` `{` ` ` `// Stores the pair of element` ` ` `// and their positions` ` ` `vector<pair<` `int` `, ` `int` `> > v;` ` ` `// Traverse the array arr[]` ` ` `for` `(` `int` `i = 0; i < N; i++)` ` ` `// Push the pair {arr[i], i} in v` ` ` `v.push_back({ arr[i], i });` ` ` `// Sort the vector in ascending order.` ` ` `sort(v.begin(), v.end());` ` ` `// Stores the total cost` ` ` `int` `ans = 0;` ` ` `// Stores the index of last element visited` ` ` `int` `last = 0;` ` ` `// Traverse the vector v` ` ` `for` `(` `auto` `j : v) {` ` ` `// Increment ans` ` ` `ans += ` `abs` `(j.second - last);` ` ` `// Assign` ` ` `last = j.second;` ` ` `}` ` ` `// Return ans` ` ` `return` `ans;` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `arr[] = { 4, 3, 2, 5, 1 };` ` ` `int` `N = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]);` ` ` `cout << calculateDistance(arr, N);` `}` |

## Java

`// java program for the above approach` `import` `java.io.*;` `import` `java.lang.*;` `import` `java.util.*;` `class` `GFG {` ` ` `// Pair class` ` ` `static` `class` `Pair {` ` ` `int` `first;` ` ` `int` `second;` ` ` `Pair(` `int` `first, ` `int` `second)` ` ` `{` ` ` `this` `.first = first;` ` ` `this` `.second = second;` ` ` `}` ` ` `}` ` ` `// Function to calculate total` ` ` `// cost of visiting array` ` ` `// elements in increasing order` ` ` `static` `int` `calculateDistance(` `int` `arr[], ` `int` `N)` ` ` `{` ` ` `// Stores the pair of element` ` ` `// and their positions` ` ` `Pair v[] = ` `new` `Pair[N];` ` ` `// Traverse the array arr[]` ` ` `for` `(` `int` `i = ` `0` `; i < N; i++)` ` ` `// Push the pair {arr[i], i} in v` ` ` `v[i] = ` `new` `Pair(arr[i], i);` ` ` `// Sort the vector in ascending order.` ` ` `Arrays.sort(v, (p1, p2) -> {` ` ` `if` `(p1.first != p2.first)` ` ` `return` `p1.first - p2.first;` ` ` `return` `p1.second - p2.second;` ` ` `});` ` ` `// Stores the total cost` ` ` `int` `ans = ` `0` `;` ` ` `// Stores the index of last element visited` ` ` `int` `last = ` `0` `;` ` ` `// Traverse the vector v` ` ` `for` `(Pair j : v) {` ` ` `// Increment ans` ` ` `ans += Math.abs(j.second - last);` ` ` `// Assign` ` ` `last = j.second;` ` ` `}` ` ` `// Return ans` ` ` `return` `ans;` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `main(String[] args)` ` ` `{` ` ` `int` `arr[] = { ` `4` `, ` `3` `, ` `2` `, ` `5` `, ` `1` `};` ` ` `int` `N = arr.length;` ` ` `// Function call` ` ` `System.out.println(calculateDistance(arr, N));` ` ` `}` `}` `// This code is contributed by Kingash.` |

## Python3

`# Python3 implementation of the above approach` `# Function to calculate total` `# cost of visiting array` `# elements in increasing order` `def` `calculateDistance(arr, N):` ` ` `# Stores the pair of element` ` ` `# and their positions` ` ` `v ` `=` `[]` ` ` `# Traverse the array arr[]` ` ` `for` `i ` `in` `range` `(N):` ` ` `# Push the pair {arr[i], i} in v` ` ` `v.append([arr[i], i])` ` ` `# Sort the vector in ascending order.` ` ` `v.sort()` ` ` `# Stores the total cost` ` ` `ans ` `=` `0` ` ` `# Stores the index of last element visited` ` ` `last ` `=` `0` ` ` `# Traverse the vector v` ` ` `for` `j ` `in` `v:` ` ` `# Increment ans` ` ` `ans ` `+` `=` `abs` `(j[` `1` `] ` `-` `last)` ` ` `# Assign` ` ` `last ` `=` `j[` `1` `]` ` ` `# Return ans` ` ` `return` `ans` `# Driver Code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `arr ` `=` `[ ` `4` `, ` `3` `, ` `2` `, ` `5` `, ` `1` `]` ` ` `N ` `=` `len` `(arr)` ` ` ` ` `print` `(calculateDistance(arr, N))` ` ` `# This code is contributed by AnkThon` |

## Javascript

`<script>` `// Javascript implementation of the above approach` `// Function to calculate total` `// cost of visiting array` `// elements in increasing order` `function` `calculateDistance(arr, N)` `{` ` ` `// Stores the pair of element` ` ` `// and their positions` ` ` `var` `v = [];` ` ` ` ` `// Traverse the array arr[]` ` ` `for` `(` `var` `i = 0; i < N; i++)` ` ` `{` ` ` `// Push the pair {arr[i], i} in v` ` ` `v.push([ arr[i], i ]);` ` ` `}` ` ` `// Sort the vector in ascending order.` ` ` `v = v.sort();` ` ` `// Stores the total cost` ` ` `var` `ans = 0;` ` ` `// Stores the index of last element visited` ` ` `var` `last = 0;` ` ` `// Traverse the vector v` ` ` `for` `(` `var` `i = 0; i < N; i++)` ` ` `{` ` ` `// Increment ans` ` ` `ans += Math.abs(v[i][1] - last);` ` ` `// Assign` ` ` `last = v[i][1];` ` ` `}` ` ` `// Return ans` ` ` `return` `ans;` `}` `// Driver Code` `var` `arr = [ 4, 3, 2, 5, 1 ];` `var` `N = arr.length;` `document.write(calculateDistance(arr, N));` `// This code is contributed by Shubhamsingh10` `</script>` |

**Output:**

11

**Time Complexity: **O(N)**Auxiliary Space:** O(N)

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**.