Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

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

  • Last Updated : 03 Jan, 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[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 <bits/stdc++.h>
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<pair<int, int> > 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

Javascript




<script>
    // JavaScript program for the above approach
 
    // Function to count minimum number
    // of jumps required to sort the array
    const minJumps = (arr, jump, N) => {
     
        // Stores minimum number of jumps
        let jumps = 0;
 
        // Stores distances of jumps
        let temp = new Array(1000).fill(0);
 
        // Stores the array elements
        // with their starting indices
        let vect = [];
 
        // Push the pairs {arr[i], i+1}
        // into the vector of pairs vect
        for (let i = 0; i < N; i++) {
 
            // Update vect
            vect.push([arr[i], i + 1]);
        }
 
        // Populate the array temp[]
        for (let i = 0; i < N; i++) {
 
            // Update temp[arr[i]]
            temp[arr[i]] = jump[i];
        }
 
        // Sort the vector in
        // the ascending order
        vect.sort();
 
        for (let 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] = [vect[i][0],
                vect[i][1]
                + temp[vect[i][0]]];
 
                // Increment the
                // number of jumps
                jumps++;
            }
        }
 
        // Print the minimum number
        // of jumps required
        document.write(`${jumps}<br/>`);
    }
 
    // Driver Code
 
    // Input
    let arr = [3, 2, 1];
    let jump = [1, 1, 1];
 
    // Size of the array
    let N = arr.length;
 
    minJumps(arr, jump, N);
 
// This code is contributed by rakeshsahni
 
</script>
Output: 
6

 

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

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!