Related Articles
Minimum number of jumps required to sort the given array in ascending order
• Last Updated : 30 Mar, 2021

Given two arrays arr[] and jump[], each of length N, where jump[i] denotes the number of indices by which the ith element in the array arr[] can move forward, the task is to find the minimum number of jumps required such that the array is sorted in ascending order.

Note:
All elements of the array arr[] are distinct.
While jumping, array elements can overlap (i.e. lie on the same index).
Array elements can move to the indices exceeding the size of the array.

Examples:

Input: arr[] = {3, 1, 2}, jump[] = {1, 4, 5}
Output: 3
Explanation:
Following sequence requires minimum number of jumps to sort the array in ascending order:
Jump 1: arr[0] jumps by 1 ( = jump[0]) index to index 1.
Jump 2: arr[0] jumps by 1 ( = jump[0]) index to index 2.
Jump 3: arr[0] jumps by 1 ( = jump[0]) index to index 3.
Therefore, the minimum number of operations required is 3.

Input: arr[] = {3, 2, 1}, jump[] = {1, 1, 1}
Output: 6
Explanation:
Following sequence requires minimum number of jumps to sort the array in ascending order:
Jump 1: arr[0] jumps by 1 ( = jump[0]) index to the index 1.
Jump 2: arr[0] jumps by 1 ( = jump[0]) index to the index 2.
Jump 3: arr[0] jumps by 1 ( = jump[0]) index to the index 3.
Jump 4: arr[1] jumps by 1 ( = jump[0]) index to the index 2.
Jump 5: arr[1] jumps by 1 ( = jump[0]) index to the index 3.
Jump 6: arr[0] jumps by 1 ( = jump[0]) index to the index 4.
Therefore, the minimum number of operations required is 6.

Approach: The given problem can be solved greedily. Follow the steps below to solve the problem:

• Initialize a variable, say jumps = 0, to store the minimum number of jumps required.
• Initialize an array, say temp[], where temp[arr[i]] stores the distance that can be jumped by arr[i]
• Initialize a vector of pairs, say vect, to store the elements of the array arr[] and their respective indices i.e {arr[i], i + 1}
• Sort the vector vect.
• Traverse the vector vect, over the range of indices [1, N – 1]. Update the value of vect[i] while vect[i].second vect[i-1].second, by adding the distance of jump to vect[i].second.
• Increment jumps by 1.
• Print the value of jumps.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to count minimum number``// of jumps required to sort the array``void` `minJumps(``int` `arr[], ``int` `jump[], ``int` `N)``{``    ``// Stores minimum number of jumps``    ``int` `jumps = 0;` `    ``// Stores distances of jumps``    ``int` `temp[1000];` `    ``// Stores the array elements``    ``// with their starting indices``    ``vector > vect;` `    ``// Push the pairs {arr[i], i+1}``    ``// into the vector of pairs vect``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Update vect``        ``vect.push_back({ arr[i], i + 1 });``    ``}` `    ``// Populate the array temp[]``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Update temp[arr[i]]``        ``temp[arr[i]] = jump[i];``    ``}` `    ``// Sort the vector in``    ``// the ascending order``    ``sort(vect.begin(), vect.end());` `    ``for` `(``int` `i = 1; i < N; i++) {``        ``// Jump till the previous``        ``// index <= current index``        ``while` `(vect[i].second <= vect[i - 1].second) {``            ``// Update vect[i]``            ``vect[i] = make_pair(vect[i].first,``                                ``vect[i].second``                                    ``+ temp[vect[i].first]);` `            ``// Increment the``            ``// number of jumps``            ``jumps++;``        ``}``    ``}` `    ``// Print the minimum number``    ``// of jumps required``    ``cout << jumps << endl;``}` `// Driver Code``int` `main()``{``    ``// Input``    ``int` `arr[] = { 3, 2, 1 };``    ``int` `jump[] = { 1, 1, 1 };` `    ``// Size of the array``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``minJumps(arr, jump, N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.lang.*;``import` `java.util.*;` `class` `GFG{` `// Function to count minimum number``// of jumps required to sort the array``static` `void` `minJumps(``int` `arr[], ``int` `jump[], ``int` `N)``{``    ` `    ``// Stores minimum number of jumps``    ``int` `jumps = ``0``;` `    ``// Stores distances of jumps``    ``int` `temp[] = ``new` `int``[``1000``];` `    ``// Stores the array elements``    ``// with their starting indices``    ``int` `vect[][] = ``new` `int``[N][``2``];` `    ``// Push the pairs {arr[i], i+1}``    ``// into the vector of pairs vect``    ``for``(``int` `i = ``0``; i < N; i++)``    ``{``        ` `        ``// Update vect``        ``vect[i][``0``] = arr[i];``        ``vect[i][``1``] = i + ``1``;``    ``}` `    ``// Populate the array temp[]``    ``for``(``int` `i = ``0``; i < N; i++)``    ``{``        ` `        ``// Update temp[arr[i]]``        ``temp[arr[i]] = jump[i];``    ``}` `    ``// Sort the vector in``    ``// the ascending order``    ``Arrays.sort(vect, (a, b) -> {``        ``if` `(a[``0``] != b[``0``])``            ``return` `a[``0``] - b[``0``];``            ` `        ``return` `a[``1``] - b[``1``];``    ``});` `    ``for``(``int` `i = ``1``; i < N; i++)``    ``{``        ` `        ``// Jump till the previous``        ``// index <= current index``        ``while` `(vect[i][``1``] <= vect[i - ``1``][``1``])``        ``{``            ` `            ``// Update vect[i]``            ``vect[i][``0``] = vect[i][``0``];``            ``vect[i][``1``] = vect[i][``1``] + temp[vect[i][``0``]];` `            ``// Increment the``            ``// number of jumps``            ``jumps++;``        ``}``    ``}` `    ``// Print the minimum number``    ``// of jumps required``    ``System.out.println(jumps);``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ` `    ``// Input``    ``int` `arr[] = { ``3``, ``2``, ``1` `};``    ``int` `jump[] = { ``1``, ``1``, ``1` `};` `    ``// Size of the array``    ``int` `N = arr.length;` `    ``minJumps(arr, jump, N);``}``}` `// This code is contributed by Kingash`

## Python3

 `# Python3 program for the above approach` `# Function to count minimum number``# of jumps required to sort the array``def` `minJumps(arr, jump, N):``    ` `    ``# Stores minimum number of jumps``    ``jumps ``=` `0` `    ``# Stores distances of jumps``    ``temp ``=` `[``0` `for` `i ``in` `range``(``1000``)]` `    ``# Stores the array elements``    ``# with their starting indices``    ``vect ``=` `[]``    ` `    ``# Push the pairs {arr[i], i+1}``    ``# into the vector of pairs vect``    ``for` `i ``in` `range``(N):``        ` `        ``# Update vect``        ``vect.append([arr[i], i ``+` `1``])` `    ``# Populate the array temp[]``    ``for` `i ``in` `range``(N):``        ` `        ``# Update temp[arr[i]]``        ``temp[arr[i]] ``=` `jump[i]` `    ``# Sort the vector in``    ``# the ascending order``    ``vect.sort(reverse ``=` `False``)` `    ``for` `i ``in` `range``(N):``        ` `        ``# Jump till the previous``        ``# index <= current index``        ``while` `(vect[i][``1``] <``=` `vect[i ``-` `1``][``1``]):``            ` `            ``# Update vect[i]``            ``vect[i] ``=` `[vect[i][``0``], vect[i][``1``] ``+``                  ``temp[vect[i][``0``]]]` `            ``# Increment the``            ``# number of jumps``            ``jumps ``+``=` `1` `    ``# Print the minimum number``    ``# of jumps required``    ``print``(jumps)` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``# Input``    ``arr ``=`  `[``3``, ``2``, ``1``]``    ``jump ``=` `[``1``, ``1``, ``1``]` `    ``# Size of the array``    ``N ``=` `len``(arr)` `    ``minJumps(arr, jump, N)` `# This code is contributed by SURENDRA_GANGWAR`
Output:
`6`

Time Complexity: O(N2)
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.

My Personal Notes arrow_drop_up