 Open in App
Not now

# Minimum number of jumps required to sort the given array in ascending order

• Last Updated : 25 May, 2022

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 jumps by 1 ( = jump) index to index 1.
Jump 2: arr jumps by 1 ( = jump) index to index 2.
Jump 3: arr jumps by 1 ( = jump) 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 jumps by 1 ( = jump) index to the index 1.
Jump 2: arr jumps by 1 ( = jump) index to the index 2.
Jump 3: arr jumps by 1 ( = jump) index to the index 3.
Jump 4: arr jumps by 1 ( = jump) index to the index 2.
Jump 5: arr jumps by 1 ( = jump) index to the index 3.
Jump 6: arr jumps by 1 ( = jump) 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;` `    ``// 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);` `    ``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`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Linq;``using` `System.Collections.Generic;` `class` `GFG {``    ``public` `class` `pair {``    ``public` `int` `first, second;`` ` `    ``public` `pair(``int` `first, ``int` `second) {``      ``this``.first = first;``      ``this``.second = second;``    ``}``  ``}``     ` `// 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``;`` ` `    ``// Stores the array elements``    ``// with their starting indices``    ``List vect;``    ``vect = ``new` `List();`` ` `    ``// Push the pairs {arr[i], i+1}``    ``// into the vector of pairs vect``    ``for``(``int` `i = 0; i < N; i++)``    ``{``         ` `        ``// Update vect``        ``vect.Add(``new` `pair(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``    ``vect.Sort((a, b) => { ``if` `(a.first != b.first)``            ``return` `a.first - b.first;``             ` `        ``return` `a.second - b.second; });``        ` ` ` `    ``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].first = vect[i].first;``            ``vect[i].second = vect[i].second + temp[vect[i].first];`` ` `            ``// Increment the``            ``// number of jumps``            ``jumps++;``        ``}``    ``}`` ` `    ``// Print the minimum number``    ``// of jumps required``    ``Console.WriteLine(jumps);``}`` ` `    ``// Driver program``    ``public` `static` `void` `Main()``    ``{``        ``// Input``        ``int``[] arr = ``new` `int``[] { 3, 2, 1 };``        ``int``[] jump = ``new` `int``[] { 1, 1, 1 };`` ` `        ``// Size of the array``        ``int` `N = arr.Length;`` ` `        ``minJumps(arr, jump, N);``    ``}``}` `// This code is contributed by Pushpesh Raj.`

## Javascript

 ``

Output:

`6`

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

My Personal Notes arrow_drop_up