Minimum number of jumps to reach end - GeeksforGeeks

20 Apr, 2022
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, they cannot move through that element. 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. 
If 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.
The first element is 1, so can only go to 3. The second element is 3, so can make at most 3 steps eg to 5 or 8 or 9.
Method 1: Naive Recursive Approach. Approach: A naive approach is to start from the first element and recursively call for all the elements reachable from first element. The minimum number of jumps to reach end from first can be calculated using minimum number of jumps needed to reach end from the elements reachable from first. 
minJumps(start, end) = Min ( minJumps(k, end) ) for all k reachable from start 
C++
C
Java
Python3
C#
PHP
Javascript
// 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 Codeint main(){    int arr[] = { 1, 3, 6, 3, 2,                  3, 6, 8, 9, 5 };    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 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 functionint main(){    int arr[] = { 1, 3, 6, 3, 2, 3, 6, 8, 9, 5 };    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 program to find Minimum// number of jumps to reach endimport java.util.*;import java.io.*; 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, 6, 3, 2, 3, 6, 8, 9, 5 };        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 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 functionarr = [1, 3, 6, 3, 2, 3, 6, 8, 9, 5]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# program to find Minimum// number of jumps to reach endusing 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, 6, 3, 2, 3, 6, 8, 9, 5 };        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 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 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.    $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, 6, 3, 2, 3, 6, 8, 9, 5);$n = count($arr); echo "Minimum number of jumps to reach "     . "end is ". minJumps($arr, 0, $n-1);     // This code is contributed by Sam007?>
<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, 6, 3, 2,                  3, 6, 8, 9, 5 ];    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 end is 4
Complexity Analysis: 
Time complexity: O(n^n). There are maximum n possible ways to move from a element. So maximum number of steps can be N^N so the upperbound of time complexity is O(n^n)
Auxiliary Space: O(1). There is no space required (if recursive stack space is ignored).
Note: If the execution is traced for this method, it can be seen that there will be overlapping subproblems. For example, 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. 
Method 2: Dynamic Programming. Approach: 
In this way, make a 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 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 MAXFinally, return jumps[n-1].
In this way, make a 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 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
Finally, return jumps[n-1].
C++
C
Java
Python3
C#
PHP
Javascript
// 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 codeint main(){    int arr[] = { 1, 3, 6, 1, 0, 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 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 functionint main(){    int arr[] = { 1, 3, 6, 1, 0, 9 };    int size = sizeof(arr) / sizeof(int);    printf("Minimum number of jumps to reach end is %d ",           minJumps(arr, size));    return 0;}
// JAVA Code for Minimum number// of jumps to reach endclass 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, 6, 1, 0, 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 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 functionarr = [1, 3, 6, 1, 0, 9]size = len(arr)print('Minimum number of jumps to reach',      'end is', minJumps(arr, size)) # This code is contributed by Soumen Ghosh
// C# Code for Minimum number of jumps to reach endusing 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, 6, 1, 0, 9 };        Console.Write("Minimum number of jumps to reach end is : " + minJumps(arr, arr.Length));    }} // This code is contributed by Sam007
<?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, 6, 1, 0, 9);    $size = count($arr);    echo "Minimum number of jumps to reach end is ".                             minJumps($arr, $size);                              // This code is contributed by Sam007?>
<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 functionvar arr = [ 1, 3, 6, 1, 0, 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^2) 
Auxiliary Space: O(n)
Method 3: Dynamic Programming. In this method, we build jumps[] array from right to left such that jumps[i] indicates the minimum number of jumps needed to reach arr[n-1] from arr[i]. Finally, we return jumps[0]. 
C++
C
Java
Python3
C#
PHP
Javascript
// 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 endint 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 functionint main(){    int arr[] = { 1, 3, 6, 1, 0, 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 program to find Minimum number of jumps to reach end#include <limits.h>#include <stdio.h> // Returns Minimum number of jumps to reach endint 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 functionint main(){    int arr[] = { 1, 3, 6, 1, 0, 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 program to find Minimum number of jumps to reach endclass 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, 6, 1, 0, 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 program to find Minimum# number of jumps to reach end # Returns Minimum number of# jumps to reach enddef 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 functionarr = [1, 3, 6, 3, 2, 3, 6, 8, 9, 5]n = len(arr)print('Minimum number of jumps to reach',      'end is', minJumps(arr, n-1))       # This code is contributed by Soumen Ghosh
// C# program to find Minimum// number of jumps to reach endusing 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, 6, 1, 0, 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 program to find Minimum// number of jumps to reach end // Returns Minimum number of jumps// to reach endfunction 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, 6, 1, 0, 9);$size = sizeof($arr);echo "Minimum number of jumps to reach",     " end is ", minJumps($arr, $size); // This code is contributed by ajit.?>
<script>// javascript program to find Minimum// number of jumps to reach end // Returns Minimum number// of jumps to reach endfunction 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 Codevar arr = [ 1, 3, 6, 1, 0, 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
Complexity Analysis: 
Time complexity:O(n^2). 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.
Sam007
Mithun Kumar
shrikanth13
Shivi_Aggarwal
jit_t
rathbhupendra
PaneerParatha69
gp6
andrew1234
avinabaray
nads
snape_here
code_hunt
bishnuamola9
shikhasingrajput
amit143katiyar
abhishek0719kadiyan
ashwinichourasiavns
as5853535
shubhambiyani10
subham348
simranarora5sos
krisania804
Adobe
Amazon
Housing.com
Moonfrog Labs
Morgan Stanley
OYO Rooms
SAP Labs
Walmart
Dynamic Programming
Mathematical
Moonfrog Labs
Morgan Stanley
Amazon
OYO Rooms
Housing.com
Walmart
Adobe
SAP Labs
Dynamic Programming
Mathematical
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Bellman–Ford Algorithm | DP-23
Floyd Warshall Algorithm | DP-16
Subset Sum Problem | DP-25
Matrix Chain Multiplication | DP-8
Longest Palindromic Substring | Set 1
Write a program to print all permutations of a given string
C++ Data Types
Set in C++ Standard Template Library (STL)
Merge two sorted arrays
Modulo Operator (%) in C/C++ with Examples