Minimum number of jumps to reach end | Set 2 (O(n) solution)

Given an array of integers where each element represents the max number of steps that can be made forward from that element. Write a function to return the minimum number of jumps to reach the end of the array (starting from the first element). If an element is 0, then we cannot move through that element.

Examples:

Input :  arr[] = {1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9}
Output :  3 (1-> 3 -> 8 -> 9)

In this post, its O(n) solution will be discussed.

In Set -1, O(n2) solution is discussed.



Implementation:
Variables to be used:

    1. maxReach The variable maxReach stores at all time the maximal reachable index in the array.
    2. step The variable step stores the number of steps we can still take(and is initialized with value at index 0,i.e. initial number of steps)
    3. jump jump stores the amount of jumps necessary to reach that maximal reachable position.

Given array arr = 1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9

  • maxReach = arr[0]; // arr[0] = 1, so the maximum index we can reach at the moment is 1.
    step = arr[0]; // arr[0] = 1, the amount of steps we can still take is also 1.
    jump = 1; // we will always need to take at least one jump.
  • Now, starting iteration from index 1, the above values are updated as follows:
      1. First we test whether we have reached the end of the array, in that case we just need to return the jump variable.

        if (i == arr.length - 1)
            return jump;
        
      2. Next we update the maxReach. This is equal to the maximum of maxReach and i+arr[i](the number of steps we can take from the current position).
        maxReach = Math.max(maxReach,i+arr[i]);
        
      3. We used up a step to get to the current index, so steps has to be decreased.
        step--;
        
      4. If no more steps are remaining (i.e. steps=0, then we must have used a jump. Therefore increase jump. Since we know that it is possible somehow to reach maxReach, we again initialize the steps to the number of steps to reach maxReach from position i. But before re-initializing step, we also check whether a step is becoming zero or negative. In this case, It is not possible to reach further.
        if (step == 0) {
            jump++;
            if(i>=maxReach)
               return -1;
            step = maxReach - i;
        }
        

C

filter_none

edit
close

play_arrow

link
brightness_4
code

// C program to count Minimum number
// of jumps to reach end
#include <stdio.h>
  
int max(int x, int y) { return (x > y)? x: y; }
  
// Returns minimum number of jumps to reach arr[n-1] from arr[0]
int minJumps(int arr[], int n)
{
      
    // The number of jumps needed to reach the starting index is 0
    if (n <= 1)
        return 0;
  
    // Return -1 if not possible to jump
    if (arr[0] == 0)
        return -1;
  
    // initialization
    int maxReach = arr[0];  // stores all time the maximal reachable index in the array.
    int step = arr[0];      // stores the number of steps we can still take
    int jump =1;//stores the number of jumps necessary to reach that maximal reachable position.
  
    // Start traversing array
    int i=1;
    for (i = 1; i < n; i++)
    {
        // Check if we have reached the end of the array
        if (i == n-1)
            return jump;
  
        // updating maxReach
        maxReach = max(maxReach, i+arr[i]);
  
        // we use a step to get to the current index
        step--;
  
        // If no further steps left
        if (step == 0)
        {
            // we must have used a jump
            jump++;
  
            // Check if the current index/position or lesser index
            // is the maximum reach point from the previous indexes
            if(i >= maxReach)
                return -1;
  
            // re-initialize the steps to the amount
            // of steps to reach maxReach from position i.
            step = maxReach - i;
        }
    }
  
    return -1;
}
  
// Driver program to test above function
int main()
{
    int arr[]={1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9};
    int size = sizeof(arr)/sizeof(int);
  
    // Calling the minJumps function
    printf("Minimum number of jumps to reach end is %d ", minJumps(arr,size));
    return 0;
}
// This code is contributed by Abhishek Kumar Singh

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to count Minimum number
// of jumps to reach end
  
class Test
{
    static int minJumps(int arr[])
    {
        if (arr.length <= 1)
            return 0;
  
        // Return -1 if not possible to jump
        if (arr[0] == 0)
            return -1;
  
        // initialization
        int maxReach = arr[0];
        int step = arr[0];
        int jump = 1;
  
  
        // Start traversing array
        for (int i = 1; i < arr.length; i++)
        {
            // Check if we have reached the end of the array
            if (i == arr.length - 1)
                return jump;
  
            // updating maxReach
            maxReach = Math.max(maxReach, i+arr[i]);
  
            // we use a step to get to the current index
            step--;
  
            // If no further steps left
            if (step == 0)
            {
                //  we must have used a jump
                jump++;
                   
                //Check if the current index/position  or lesser index
                // is the maximum reach point from the previous indexes
                if(i>=maxReach)
                   return -1;
  
                // re-initialize the steps to the amount
                // of steps to reach maxReach from position i.
                step = maxReach - i;
            }
        }
  
        return -1;
    }
  
    // Driver method to test the above function
    public static void main(String[] args)
    {
        int arr[] = new int[] {1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9};
  
        // calling minJumps method
        System.out.println(minJumps(arr));
    }
}

chevron_right


Python

filter_none

edit
close

play_arrow

link
brightness_4
code

# python program to count Minimum number
# of jumps to reach end
   
# Returns minimum number of jumps to reach arr[n-1] from arr[0]
def minJumps(arr, n):
  # The number of jumps needed to reach the starting index is 0
  if (n <= 1):
    return 0
   
  # Return -1 if not possible to jump
  if (arr[0] == 0):
    return -1
   
  # initialization
  # stores all time the maximal reachable index in the array
  maxReach = arr[0]  
  # stores the amount of steps we can still take
  step = arr[0]
  # stores the amount of jumps necessary to reach that maximal reachable position
  jump =1 
   
  # Start traversing array
   
  for i in range(1,n):
    # Check if we have reached the end of the array
    if (i == n-1):
      return jump
   
    # updating maxReach
    maxReach = max(maxReach, i+arr[i])
   
    # we use a step to get to the current index
    step -= 1;
   
    # If no further steps left
    if (step == 0):
      # we must have used a jump
      jump += 1
        
      # Check if the current index/position or lesser index
      # is the maximum reach point from the previous indexes
      if(i >= maxReach):
        return -1
   
      # re-initialize the steps to the amount
      # of steps to reach maxReach from position i.
      step = maxReach - i;
  return -1
   
  
# Driver program to test above function
arr = [1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9]
size = len(arr)
   
# Calling the minJumps function
print("Minimum number of jumps to reach end is %d " %minJumps(arr,size))
  
  
# This code is contributed by Aditi Sharma

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to count Minimum 
// number of jumps to reach end
using System; 
  
class GFG
{
    static int minJumps(int []arr)
    {
        if (arr.Length <= 1)
            return 0;
  
        // Return -1 if not 
        // possible to jump
        if (arr[0] == 0)
            return -1;
  
        // initialization
        int maxReach = arr[0];
        int step = arr[0];
        int jump = 1;
  
  
        // Start traversing array
        for (int i = 1; i < arr.Length; i++)
        {
            // Check if we have reached 
            // the end of the array
            if (i == arr.Length - 1)
                return jump;
  
            // updating maxReach
            maxReach = Math.Max(maxReach, i + arr[i]);
  
            // we use a step to get
            // to the current index
            step--;
  
            // If no further steps left
            if (step == 0)
            {
                // we must have used a jump
                jump++;
                  
                // Check if the current index/position 
                // or lesser index is the maximum reach
                // point from the previous indexes
                if(i >= maxReach)
                return -1;
  
                // re-initialize the steps to
                // the amount of steps to reach 
                // maxReach from position i.
                step = maxReach - i;
            }
        }
  
        return -1;
    }
  
    // Driver Code
    public static void Main()
    {
        int []arr = new int[] {1, 3, 5, 8, 9, 2,
                               6, 7, 6, 8, 9};
  
        // calling minJumps method
        Console.Write(minJumps(arr));
    }
}
  
// This code is contributed 
// by nitin mittal

chevron_right



Output:

3

References :- Stackoverflow

Thanks to Chiranjeev Jain for suggesting this solution.

This article is contributed by Sahil Chhabra and Gaurav Miglani. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



My Personal Notes arrow_drop_up

Improved By : nitin mittal