Minimum number of jumps to reach end

Difficulty Level : Medium
Last Updated : 28 Sep, 2022

Read

Discuss(660+)

Given an array arr[] where each element represents the max number of steps that can be made forward from that index. The task is to find the minimum number of jumps to reach the end of the array starting from index 0. If the end isn’t reachable, return -1.

Examples:

Input: arr[] = {1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9}
Output: 3 (1-> 3 -> 9 -> 9)
Explanation: Jump from 1st element to 2nd element as there is only 1 step.
Now there are three options 5, 8 or 9. I
f 8 or 9 is chosen then the end node 9 can be reached. So 3 jumps are made.

Input: arr[] = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}
Output: 10
Explanation: In every step a jump is needed so the count of jumps is 10.

Minimum number of jumps to reach the end using Recursion:

Start from the first element and recursively call for all the elements reachable from the first element. The minimum number of jumps to reach end from first can be calculated using the minimum value from the recursive calls.

minJumps(start, end) = Min ( minJumps(k, end) ) for all k reachable from start.

Follow the steps mentioned below to implement the idea:

Create a recursive function.
In each recursive call get all the reachable nodes from that index.
- For each of the index call the recursive function.
- Find the minimum number of jumps to reach the end from current index.
Return the minimum number of jumps from the recursive call.

Below is the Implementation of the above approach:

C++

// C++ program to find Minimum
// number of jumps to reach end
#include <bits/stdc++.h>
using namespace std;
 
// Function to return the minimum number
// of jumps to reach arr[h] from arr[l]
int minJumps(int arr[], int n)
{
 
    // Base case: when source and
    // destination are same
    if (n == 1)
        return 0;
 
    // Traverse through all the points
    // reachable from arr[l]
    // Recursively, get the minimum number
    // of jumps needed to reach arr[h] from
    // these reachable points
    int res = INT_MAX;
    for (int i = n - 2; i >= 0; i--) {
        if (i + arr[i] >= n - 1) {
            int sub_res = minJumps(arr, i + 1);
            if (sub_res != INT_MAX)
                res = min(res, sub_res + 1);
        }
    }
 
    return res;
}
 
// Driver Code
int main()
{
    int arr[] = { 1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9 };
    int n = sizeof(arr) / sizeof(arr[0]);
    cout << "Minimum number of jumps to";
    cout << " reach the end is " << minJumps(arr, n);
    return 0;
}
 
// This code is contributed
// by Shivi_Aggarwal

C

// C program to find Minimum
// number of jumps to reach end
#include <limits.h>
#include <stdio.h>
 
// Returns minimum number of
// jumps to reach arr[h] from arr[l]
int minJumps(int arr[], int l, int h)
{
    // Base case: when source and destination are same
    if (h == l)
        return 0;
 
    // When nothing is reachable from the given source
    if (arr[l] == 0)
        return INT_MAX;
 
    // Traverse through all the points
    // reachable from arr[l]. Recursively
    // get the minimum number of jumps
    // needed to reach arr[h] from these
    // reachable points.
    int min = INT_MAX;
    for (int i = l + 1; i <= h && i <= l + arr[l]; i++) {
        int jumps = minJumps(arr, i, h);
        if (jumps != INT_MAX && jumps + 1 < min)
            min = jumps + 1;
    }
 
    return min;
}
 
// Driver program to test above function
int main()
{
    int arr[] = { 1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9 };
    int n = sizeof(arr) / sizeof(arr[0]);
    printf("Minimum number of jumps to reach end is %d ",
           minJumps(arr, 0, n - 1));
    return 0;
}

Java

// Java program to find Minimum
// number of jumps to reach end
import java.io.*;
import java.util.*;
 
class GFG {
    // Returns minimum number of
    // jumps to reach arr[h] from arr[l]
    static int minJumps(int arr[], int l, int h)
    {
        // Base case: when source
        // and destination are same
        if (h == l)
            return 0;
 
        // When nothing is reachable
        // from the given source
        if (arr[l] == 0)
            return Integer.MAX_VALUE;
 
        // Traverse through all the points
        // reachable from arr[l]. Recursively
        // get the minimum number of jumps
        // needed to reach arr[h] from these
        // reachable points.
        int min = Integer.MAX_VALUE;
        for (int i = l + 1; i <= h && i <= l + arr[l];
             i++) {
            int jumps = minJumps(arr, i, h);
            if (jumps != Integer.MAX_VALUE
                && jumps + 1 < min)
                min = jumps + 1;
        }
        return min;
    }
 
    // Driver code
    public static void main(String args[])
    {
        int arr[] = { 1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9 };
        int n = arr.length;
        System.out.print(
            "Minimum number of jumps to reach end is "
            + minJumps(arr, 0, n - 1));
    }
}
 
// This code is contributed by Sahil_Bansall

Python3

# Python3 program to find Minimum
# number of jumps to reach end
 
# Returns minimum number of jumps
# to reach arr[h] from arr[l]
 
 
def minJumps(arr, l, h):
 
    # Base case: when source and
    # destination are same
    if (h == l):
        return 0
 
    # when nothing is reachable
    # from the given source
    if (arr[l] == 0):
        return float('inf')
 
    # Traverse through all the points
    # reachable from arr[l]. Recursively
    # get the minimum number of jumps
    # needed to reach arr[h] from
    # these reachable points.
    min = float('inf')
    for i in range(l + 1, h + 1):
        if (i < l + arr[l] + 1):
            jumps = minJumps(arr, i, h)
            if (jumps != float('inf') and
                    jumps + 1 < min):
                min = jumps + 1
 
    return min
 
 
# Driver program to test above function
arr = [1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9]
n = len(arr)
print('Minimum number of jumps to reach',
      'end is', minJumps(arr, 0, n-1))
 
# This code is contributed by Soumen Ghosh

C#

// C# program to find Minimum
// number of jumps to reach end
using System;
 
class GFG {
    // Returns minimum number of
    // jumps to reach arr[h] from arr[l]
    static int minJumps(int[] arr, int l, int h)
    {
        // Base case: when source
        // and destination are same
        if (h == l)
            return 0;
 
        // When nothing is reachable
        // from the given source
        if (arr[l] == 0)
            return int.MaxValue;
 
        // Traverse through all the points
        // reachable from arr[l]. Recursively
        // get the minimum number of jumps
        // needed to reach arr[h] from these
        // reachable points.
        int min = int.MaxValue;
        for (int i = l + 1; i <= h && i <= l + arr[l];
             i++) {
            int jumps = minJumps(arr, i, h);
            if (jumps != int.MaxValue && jumps + 1 < min)
                min = jumps + 1;
        }
        return min;
    }
 
    // Driver code
    public static void Main()
    {
        int[] arr = { 1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9 };
        int n = arr.Length;
        Console.Write(
            "Minimum number of jumps to reach end is "
            + minJumps(arr, 0, n - 1));
    }
}
 
// This code is contributed by Sam007

PHP

<?php
// php program to find Minimum 
// number of jumps to reach end
 
// Returns minimum number of jumps 
// to reach arr[h] from arr[l]
function minJumps($arr, $l, $h)
{
     
    // Base case: when source and
    // destination are same
    if ($h == $l)
        return 0;
     
    // When nothing is reachable
    // from the given source
    if ($arr[$l] == 0)
        return $h+1;
     
    // Traverse through all the points 
    // reachable from arr[l]. Recursively
    // get the minimum number of jumps
    // needed to reach arr[h] from these
    // reachable points.
    $min = 999999;
     
    for ($i = $l+1; $i <= $h && 
             $i <= $l + $arr[$l]; $i++)
    {
        $jumps = minJumps($arr, $i, $h);
         
        if($jumps != 999999 && 
                     $jumps + 1 < $min)
            $min = $jumps + 1;
    }
     
    return $min;
}
 
// Driver program to test above function
$arr = array(1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9);
$n = count($arr);
 
echo "Minimum number of jumps to reach "
     . "end is ". minJumps($arr, 0, $n-1);
     
// This code is contributed by Sam007
?>

Javascript

<script>
 
// JavaScript program to find Minimum
// number of jumps to reach end
 
// Function to return the minimum number
// of jumps to reach arr[h] from arr[l]
function minJumps(arr, n)
{
 
    // Base case: when source and
    // destination are same
    if (n == 1)
        return 0;
 
    // Traverse through all the points
    // reachable from arr[l]
    // Recursively, get the minimum number
    // of jumps needed to reach arr[h] from
    // these reachable points
    let res = Number.MAX_VALUE;
    for (let i = n - 2; i >= 0; i--) {
        if (i + arr[i] >= n - 1) {
            let sub_res = minJumps(arr, i + 1);
            if (sub_res != Number.MAX_VALUE)
                res = Math.min(res, sub_res + 1);
        }
    }
 
    return res;
}
 
 
// Driver Code
 
    let arr = [ 1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9 ];
    let n = arr.length;
    document.write("Minimum number of jumps to");
    document.write(" reach end is " + minJumps(arr, n));
 
</script>

Output

Minimum number of jumps to reach the end is 3

Time complexity: O(nNⁿ).

There are maximum n possible ways to move from an element.
So the maximum number of steps can be nⁿ, Thus O(nⁿ)

Auxiliary Space: O(n). For recursion call stack.

Minimum number of jumps to reach end using Dynamic Programming from left to right:

It can be observed that there will be overlapping subproblems.

For example in array, arr[] = {1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9} minJumps(3, 9) will be called two times as arr[3] is reachable from arr[1] and arr[2]. So this problem has both properties (optimal substructure and overlapping subproblems) of Dynamic Programming

Follow the below steps to implement the idea:

Create jumps[] array from left to right such that jumps[i] indicate the minimum number of jumps needed to reach arr[i] from arr[0].
To fill the jumps array run a nested loop inner loop counter is j and the outer loop count is i.
- Outer loop from 1 to n-1 and inner loop from 0 to i.
- If i is less than j + arr[j] then set jumps[i] to minimum of jumps[i] and jumps[j] + 1. initially set jump[i] to INT MAX
Return jumps[n-1].

Below is the implementation of the above approach:

C++

// C++ program for Minimum number
// of jumps to reach end
#include <bits/stdc++.h>
using namespace std;
 
int min(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)
{
    // jumps[n-1] will hold the result
    int* jumps = new int[n];
    int i, j;
 
    if (n == 0 || arr[0] == 0)
        return INT_MAX;
 
    jumps[0] = 0;
 
    // Find the minimum number of jumps to reach arr[i]
    // from arr[0], and assign this value to jumps[i]
    for (i = 1; i < n; i++) {
        jumps[i] = INT_MAX;
        for (j = 0; j < i; j++) {
            if (i <= j + arr[j] && jumps[j] != INT_MAX) {
                jumps[i] = min(jumps[i], jumps[j] + 1);
                break;
            }
        }
    }
    return jumps[n - 1];
}
 
// Driver code
int main()
{
    int arr[] = { 1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9 };
    int size = sizeof(arr) / sizeof(int);
    cout << "Minimum number of jumps to reach end is "
         << minJumps(arr, size);
    return 0;
}
 
// This is code is contributed by rathbhupendra

C

// C program for Minimum number
// of jumps to reach end
#include <limits.h>
#include <stdio.h>
 
int min(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)
{
    // jumps[n-1] will hold the result
    int jumps[n];
    int i, j;
 
    if (n == 0 || arr[0] == 0)
        return INT_MAX;
 
    jumps[0] = 0;
 
    // Find the minimum number of
    // jumps to reach arr[i]
    // from arr[0], and assign this
    // value to jumps[i]
    for (i = 1; i < n; i++) {
        jumps[i] = INT_MAX;
        for (j = 0; j < i; j++) {
            if (i <= j + arr[j] && jumps[j] != INT_MAX) {
                jumps[i] = min(jumps[i], jumps[j] + 1);
                break;
            }
        }
    }
    return jumps[n - 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);
    printf("Minimum number of jumps to reach end is %d ",
           minJumps(arr, size));
    return 0;
}

Java

// JAVA Code for Minimum number
// of jumps to reach end
 
import java.io.*;
 
class GFG {
 
    private static int minJumps(int[] arr, int n)
    {
        // jumps[n-1] will hold the
        int jumps[] = new int[n];
        // result
        int i, j;
 
        // if first element is 0,
        if (n == 0 || arr[0] == 0)
            return Integer.MAX_VALUE;
        // end cannot be reached
 
        jumps[0] = 0;
 
        // Find the minimum number of jumps to reach arr[i]
        // from arr[0], and assign this value to jumps[i]
        for (i = 1; i < n; i++) {
            jumps[i] = Integer.MAX_VALUE;
            for (j = 0; j < i; j++) {
                if (i <= j + arr[j]
                    && jumps[j] != Integer.MAX_VALUE) {
                    jumps[i]
                        = Math.min(jumps[i], jumps[j] + 1);
                    break;
                }
            }
        }
        return jumps[n - 1];
    }
 
    // driver program to test above function
    public static void main(String[] args)
    {
        int arr[] = { 1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9 };
 
        System.out.println(
            "Minimum number of jumps to reach end is : "
            + minJumps(arr, arr.length));
    }
}
 
// This code is contributed by Arnav Kr. Mandal.

Python3

# Python3 program to find Minimum
# number of jumps to reach end
 
# Returns minimum number of jumps
# to reach arr[n-1] from arr[0]
 
 
def minJumps(arr, n):
    jumps = [0 for i in range(n)]
 
    if (n == 0) or (arr[0] == 0):
        return float('inf')
 
    jumps[0] = 0
 
    # Find the minimum number of
    # jumps to reach arr[i] from
    # arr[0] and assign this
    # value to jumps[i]
    for i in range(1, n):
        jumps[i] = float('inf')
        for j in range(i):
            if (i <= j + arr[j]) and (jumps[j] != float('inf')):
                jumps[i] = min(jumps[i], jumps[j] + 1)
                break
    return jumps[n-1]
 
 
# Driver Program to test above function
arr = [1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9]
size = len(arr)
print('Minimum number of jumps to reach',
      'end is', minJumps(arr, size))
 
# This code is contributed by Soumen Ghosh

C#

// C# Code for Minimum number of jumps to reach end
using System;
 
class GFG {
    static int minJumps(int[] arr, int n)
    {
        // jumps[n-1] will hold the
        // result
        int[] jumps = new int[n];
 
        // if first element is 0,
        if (n == 0 || arr[0] == 0)
 
            // end cannot be reached
            return int.MaxValue;
 
        jumps[0] = 0;
 
        // Find the minimum number of
        // jumps to reach arr[i]
        // from arr[0], and assign
        // this value to jumps[i]
        for (int i = 1; i < n; i++) {
            jumps[i] = int.MaxValue;
            for (int j = 0; j < i; j++) {
                if (i <= j + arr[j]
                    && jumps[j] != int.MaxValue) {
                    jumps[i]
                        = Math.Min(jumps[i], jumps[j] + 1);
                    break;
                }
            }
        }
        return jumps[n - 1];
    }
 
    // Driver program
    public static void Main()
    {
        int[] arr = { 1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9 };
        Console.Write(
            "Minimum number of jumps to reach end is : "
            + minJumps(arr, arr.Length));
    }
}
 
// This code is contributed by Sam007

PHP

<?php
// PHP code for Minimum number of
// jumps to reach end
 
// Returns minimum number of jumps
// to reach arr[n-1] from arr[0]
function minJumps($arr, $n)
{
    // jumps[n-1] will
    // hold the result
    $jumps = array($n);
     
    if ($n == 0 || $arr[0] == 0)
        return 999999;
 
    $jumps[0] = 0;
 
    // Find the minimum number of
    // jumps to reach arr[i]
    // from arr[0], and assign 
    // this value to jumps[i]
    for ($i = 1; $i < $n; $i++)
    {
        $jumps[$i] = 999999;
        for ($j = 0; $j < $i; $j++)
        {
            if ($i <= $j + $arr[$j] && 
                $jumps[$j] != 999999)
            {
                $jumps[$i] = min($jumps[$i], 
                             $jumps[$j] + 1);
                break;
            }
        }
    }
    return $jumps[$n-1];
}
 
    // Driver Code
    $arr = array(1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9);
    $size = count($arr);
    echo "Minimum number of jumps to reach end is ". 
                             minJumps($arr, $size);
                              
// This code is contributed by Sam007
?>

Javascript

<script>
 
// JavaScript Code for Minimum number
// of jumps to reach end   
function minJumps(arr , n)
 
    {
        // jumps[n-1] will hold the
        var jumps = Array.from({length: n}, (_, i) => 0);;
        // result
        var i, j;
 
        // if first element is 0,
        if (n == 0 || arr[0] == 0)
            return Number.MAX_VALUE;
        // end cannot be reached
 
        jumps[0] = 0;
 
        // Find the minimum number of jumps to reach arr[i]
        // from arr[0], and assign this value to jumps[i]
        for (i = 1; i < n; i++) {
            jumps[i] = Number.MAX_VALUE;
            for (j = 0; j < i; j++) {
                if (i <= j + arr[j]
                    && jumps[j]
                           != Number.MAX_VALUE) {
                    jumps[i] = Math.min(jumps[i], jumps[j] + 1);
                    break;
                }
            }
        }
        return jumps[n - 1];
    }
 
// driver program to test above function
var arr = [ 1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9 ];
 
document.write("Minimum number of jumps to reach end is : "
                   + minJumps(arr, arr.length));
 
// This code contributed by shikhasingrajput 
 
</script>

Output

Minimum number of jumps to reach end is 3

Thanks to paras for suggesting this method.

Time Complexity: O(n²)
Auxiliary Space: O(n), since n extra space has been taken.

Another implementation using Dynamic programming:

Build jumps[] array from right to left such that jumps[i] indicate the minimum number of jumps needed to reach arr[n-1] from arr[i]. Finally, we return jumps[0]. Use Dynamic programming in a similar way of the above method.

Below is the Implementation of the above approach:

C++

// C++ program to find Minimum number of jumps to reach end
#include <bits/stdc++.h>
using namespace std;
 
// Returns Minimum number of jumps to reach end
int minJumps(int arr[], int n)
{
    // jumps[0] will hold the result
    int* jumps = new int[n];
    int min;
 
    // Minimum number of jumps needed to reach last element
    // from last elements itself is always 0
    jumps[n - 1] = 0;
 
    // Start from the second element, move from right to
    // left and construct the jumps[] array where jumps[i]
    // represents minimum number of jumps needed to reach
    // arr[m-1] from arr[i]
    for (int i = n - 2; i >= 0; i--) {
        // If arr[i] is 0 then arr[n-1] can't be reached
        // from here
        if (arr[i] == 0)
            jumps[i] = INT_MAX;
 
        // If we can directly reach to the end point from
        // here then jumps[i] is 1
        else if (arr[i] >= n - i - 1)
            jumps[i] = 1;
 
        // Otherwise, to find out the minimum number of
        // jumps needed to reach arr[n-1], check all the
        // points reachable from here and jumps[] value for
        // those points
        else {
            // initialize min value
            min = INT_MAX;
 
            // following loop checks with all reachable
            // points and takes the minimum
            for (int j = i + 1; j < n && j <= arr[i] + i;
                 j++) {
                if (min > jumps[j])
                    min = jumps[j];
            }
 
            // Handle overflow
            if (min != INT_MAX)
                jumps[i] = min + 1;
            else
                jumps[i] = min; // or INT_MAX
        }
    }
 
    return jumps[0];
}
 
// 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);
    cout << "Minimum number of jumps to reach"
         << " end is " << minJumps(arr, size);
    return 0;
}
 
// This code is contributed by Sania Kumari Gupta

C

// C program to find Minimum number of jumps to reach end
#include <limits.h>
#include <stdio.h>
 
// Returns Minimum number of jumps to reach end
int minJumps(int arr[], int n)
{
    // jumps[0] will hold the result
    int jumps[n];
    int min;
 
    // Minimum number of jumps needed to reach last element
    // from last elements itself is always 0
    jumps[n - 1] = 0;
 
    // Start from the second element, move from right to
    // left and construct the jumps[] array where jumps[i]
    // represents minimum number of jumps needed to reach
    // arr[m-1] from arr[i]
    for (int i = n - 2; i >= 0; i--) {
        // If arr[i] is 0 then arr[n-1] can't be reached
        // from here
        if (arr[i] == 0)
            jumps[i] = INT_MAX;
 
        // If we can directly reach to the end point from
        // here then jumps[i] is 1
        else if (arr[i] >= n - i - 1)
            jumps[i] = 1;
 
        // Otherwise, to find out the minimum number of
        // jumps needed to reach arr[n-1], check all the
        // points reachable from here and jumps[] value for
        // those points
        else {
            // initialize min value
            min = INT_MAX;
 
            // following loop checks with all reachable
            // points and takes the minimum
            for (int j = i + 1; j < n && j <= arr[i] + i;
                 j++) {
                if (min > jumps[j])
                    min = jumps[j];
            }
 
            // Handle overflow
            if (min != INT_MAX)
                jumps[i] = min + 1;
            else
                jumps[i] = min; // or INT_MAX
        }
    }
 
    return jumps[0];
}
 
// 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);
    printf("Minimum number of jumps to reach end is %d ",
           minJumps(arr, size));
    return 0;
}
 
// This code is contributed by Sania Kumari Gupta

Java

// Java program to find Minimum number of jumps to reach end
 
class GFG {
    // Returns Minimum number of jumps to reach end
    static int minJumps(int arr[], int n)
    {
        // jumps[0] will hold the result
        int[] jumps = new int[n];
        int min;
 
        // Minimum number of jumps needed to reach last
        // element from last elements itself is always 0
        jumps[n - 1] = 0;
 
        // Start from the second element, move from right to
        // left and construct the jumps[] array where
        // jumps[i] represents minimum number of jumps
        // needed to reach arr[m-1] from arr[i]
        for (int i = n - 2; i >= 0; i--) {
            // If arr[i] is 0 then arr[n-1] can't be reached
            // from here
            if (arr[i] == 0)
                jumps[i] = Integer.MAX_VALUE;
 
            // If we can directly reach to the end point
            // from here then jumps[i] is 1
            else if (arr[i] >= n - i - 1)
                jumps[i] = 1;
 
            // Otherwise, to find out the minimum number of
            // jumps needed to reach arr[n-1], check all the
            // points reachable from here and jumps[] value
            // for those points
            else {
                // initialize min value
                min = Integer.MAX_VALUE;
 
                // following loop checks with all reachable
                // points and takes the minimum
                for (int j = i + 1;
                     j < n && j <= arr[i] + i; j++) {
                    if (min > jumps[j])
                        min = jumps[j];
                }
 
                // Handle overflow
                if (min != Integer.MAX_VALUE)
                    jumps[i] = min + 1;
                else
                    jumps[i] = min; // or Integer.MAX_VALUE
            }
        }
 
        return jumps[0];
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        int[] arr = { 1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9 };
        int size = arr.length;
        System.out.println(
            "Minimum number of jumps to reach end is "
            + minJumps(arr, size));
    }
}
 
// This code is contributed by Sania Kumari Gupta

Python3

# Python3 program to find Minimum
# number of jumps to reach end
 
# Returns Minimum number of
# jumps to reach end
 
 
def minJumps(arr, n):
 
    # jumps[0] will hold the result
    jumps = [0 for i in range(n)]
 
    # Minimum number of jumps needed
    # to reach last element from
    # last elements itself is always 0
    # jumps[n-1] is also initialized to 0
 
    # Start from the second element,
    # move from right to left and
    # construct the jumps[] array where
    # jumps[i] represents minimum number
    # of jumps needed to reach arr[m-1]
    # form arr[i]
    for i in range(n-2, -1, -1):
 
        # If arr[i] is 0 then arr[n-1]
        # can't be reached from here
        if (arr[i] == 0):
            jumps[i] = float('inf')
 
        # If we can directly reach to
        # the end point from here then
        # jumps[i] is 1
        elif (arr[i] >= n - i - 1):
            jumps[i] = 1
 
        # Otherwise, to find out the
        # minimum number of jumps
        # needed to reach arr[n-1],
        # check all the points
        # reachable from here and
        # jumps[] value for those points
        else:
            # initialize min value
            min = float('inf')
 
            # following loop checks with
            # all reachable points and
            # takes the minimum
            for j in range(i + 1, n):
                if (j <= arr[i] + i):
                    if (min > jumps[j]):
                        min = jumps[j]
 
            # Handle overflow
            if (min != float('inf')):
                jumps[i] = min + 1
            else:
                # or INT_MAX
                jumps[i] = min
 
    return jumps[0]
 
 
# Driver program to test above function
arr = [1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9]
n = len(arr)
print('Minimum number of jumps to reach',
      'end is', minJumps(arr, n-1))
 
# This code is contributed by Soumen Ghosh

C#

// C# program to find Minimum
// number of jumps to reach end
using System;
 
class GFG {
    // Returns Minimum number
    // of jumps to reach end
    public static int minJumps(int[] arr, int n)
    {
        // jumps[0] will
        // hold the result
        int[] jumps = new int[n];
        int min;
 
        // Minimum number of jumps needed to
        // reach last element from last elements
        // itself is always 0
        jumps[n - 1] = 0;
 
        // Start from the second element, move
        // from right to left and construct the
        // jumps[] array where jumps[i] represents
        // minimum number of jumps needed to reach
        // arr[m-1] from arr[i]
        for (int i = n - 2; i >= 0; i--) {
            // If arr[i] is 0 then arr[n-1]
            // can't be reached from here
            if (arr[i] == 0) {
                jumps[i] = int.MaxValue;
            }
 
            // If we can directly reach to the end
            // point from here then jumps[i] is 1
            else if (arr[i] >= n - i - 1) {
                jumps[i] = 1;
            }
 
            // Otherwise, to find out the minimum
            // number of jumps needed to reach
            // arr[n-1], check all the points
            // reachable from here and jumps[] value
            // for those points
            else {
                // initialize min value
                min = int.MaxValue;
 
                // following loop checks with all
                // reachable points and takes the minimum
                for (int j = i + 1;
                     j < n && j <= arr[i] + i; j++) {
                    if (min > jumps[j]) {
                        min = jumps[j];
                    }
                }
 
                // Handle overflow
                if (min != int.MaxValue) {
                    jumps[i] = min + 1;
                }
                else {
                    jumps[i] = min; // or Integer.MAX_VALUE
                }
            }
        }
 
        return jumps[0];
    }
 
    // Driver Code
    public static void Main(string[] args)
    {
        int[] arr
            = new int[] { 1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9 };
        int size = arr.Length;
        Console.WriteLine("Minimum number of"
                          + " jumps to reach end is "
                          + minJumps(arr, size));
    }
}
 
// This code is contributed by Shrikant13

PHP

<?php
// PHP program to find Minimum 
// number of jumps to reach end
 
// Returns Minimum number of jumps
// to reach end
function minJumps($arr, $n)
{ 
    // jumps[0] will hold the result
    $jumps[$n] = array(); 
    $min;
 
    // Minimum number of jumps needed 
    // to reach last element from last
    // elements itself is always 0
    $jumps[$n-1] = array(0);
 
    // Start from the second element, 
    // move from right to left and 
    // construct the jumps[] array where
    // jumps[i] represents minimum number
    // of jumps needed to reach 
    // arr[m-1] from arr[i]
    for ($i = $n - 2; $i >= 0; $i--)
    {
        // If arr[i] is 0 then arr[n-1] 
        // can't be reached from here
        if ($arr[$i] == 0)
            $jumps[$i] = PHP_INT_MAX;
 
        // If we can directly reach to 
        // the end point from here then
        // jumps[i] is 1
        else if ($arr[$i] >= ($n - $i) - 1)
            $jumps[$i] = 1;
 
        // Otherwise, to find out the minimum
        // number of jumps needed to reach 
        // arr[n-1], check all the points 
        // reachable from here and jumps[] 
        // value for those points
        else
        { 
            // initialize min value
            $min = PHP_INT_MAX; 
 
            // following loop checks with all
            // reachable points and takes 
            // the minimum
            for ($j = $i + 1; $j < $n &&
                 $j <= $arr[$i] + $i; $j++)
            {
                if ($min > $jumps[$j])
                    $min = $jumps[$j];
            } 
 
            // Handle overflow 
            if ($min != PHP_INT_MAX)
                $jumps[$i] = $min + 1;
            else
                $jumps[$i] = $min; // or INT_MAX
        }
    }
 
    return $jumps[0];
}
 
// Driver Code
$arr = array(1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9);
$size = sizeof($arr);
echo "Minimum number of jumps to reach",
     " end is ", minJumps($arr, $size);
 
// This code is contributed by ajit.
?>

Javascript

<script>
// javascript program to find Minimum
// number of jumps to reach end
 
// Returns Minimum number
// of jumps to reach end
function minJumps(arr, n)
{
    // jumps[0] will
    // hold the result
    var jumps = Array.from({length: n}, (_, i) => 0);
    var min;
 
    // Minimum number of jumps
    // needed to reach last
    // element from last elements
    // itself is always 0
    jumps[n - 1] = 0;
 
    // Start from the second
    // element, move from right
    // to left and construct the
    // jumps array where jumps[i]
    // represents minimum number of
    // jumps needed to reach arr[m-1]
    // from arr[i]
    for (i = n - 2; i >= 0; i--) {
        // If arr[i] is 0 then arr[n-1]
        // can't be reached from here
        if (arr[i] == 0)
            jumps[i] = Number.MAX_VALUE;
 
        // If we can directly reach to
        // the end point from here then
        // jumps[i] is 1
        else if (arr[i] >= n - i - 1)
            jumps[i] = 1;
 
        // Otherwise, to find out
        // the minimum number of
        // jumps needed to reach
        // arr[n-1], check all the
        // points reachable from
        // here and jumps value
        // for those points
        else {
            // initialize min value
            min = Number.MAX_VALUE;
 
            // following loop checks
            // with all reachable points
            // and takes the minimum
            for (j = i + 1; j < n && j <= arr[i] + i; j++) {
                if (min > jumps[j])
                    min = jumps[j];
            }
 
            // Handle overflow
            if (min != Number.MAX_VALUE)
                jumps[i] = min + 1;
            else
                jumps[i] = min; // or Number.MAX_VALUE
        }
    }
 
    return jumps[0];
}
 
// Driver Code
var arr = [ 1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9 ];
var size = arr.length;
document.write("Minimum number of"
                   + " jumps to reach end is " + minJumps(arr, size));
 
// This code is contributed by Amit Katiyar 
</script>

Output

Minimum number of jumps to reach end is 3

Time complexity: O(n²). Nested traversal of the array is needed.
Auxiliary Space: O(n). To store the DP array linear space is needed.

Minimum number of jumps to reach end | Set 2 (O(n) solution)
Thanks to Ashish for suggesting this solution.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

My Personal Notes