# Minimum number of jumps to reach end

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.

Examples:

```Input: arr[] = {1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9}
Output: 3 (1-> 3 -> 8 -> 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.

## Recommended: Please solve it on “PRACTICE ” first, before moving on to the solution.

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++ implementation of the approach ` `#include ` `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] ` `    ``// Recursivel, 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, 6, 3, 2, ` `                  ``3, 6, 8, 9, 5 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``cout << ``"Minimum number of jumps to"``; ` `    ``cout << ``" reach the end is "` `<< minJumps(arr, n); ` `    ``return` `0; ` `} ` ` `  `// This code is contributed ` `// by Shivi_Aggarwal `

## C

 `#include ` `#include ` ` `  `// 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, 6, 3, 2, 3, 6, 8, 9, 5 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``printf``( ` `        ``"Minimum number of jumps to reach end is %d "``, ` `        ``minJumps(arr, 0, n - 1)); ` `    ``return` `0; ` `} `

## Java

 `// Javaprogram to find Minimum ` `// number of jumps to reach end ` `import` `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

 `# 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``, ``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#

 `// 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, 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

 ` `

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 is reachable from arr and arr. So this problem has both properties (optimal substructure and overlapping subproblems) of Dynamic Programming.

Method 2: Dynamic Programming.
Approach:

1. In this way, make a jumps[] array from left to right such that jumps[i] indicates the minimum number of jumps needed to reach arr[i] from arr.
2. To fill the jumps array run a nested loop inner loop counter is j and outer loop count is j.
3. Outer loop from 1 to n-1 and inner loop from 0 to n-1.
4. 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
5. Finally, return jumps[n-1].

## C++

 `// C++ program for Minimum number ` `// of jumps to reach end ` `#include ` `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 ` `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) ` `        ``return` `INT_MAX; ` ` `  `    ``jumps = 0; ` ` `  `    ``// Find the minimum number of jumps to reach arr[i] ` `    ``// from arr, 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, 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

 `#include ` `#include ` ` `  `int` `min(``int` `x, ``int` `y) { ``return` `(x < y) ? x : y; } ` ` `  `// Returns minimum number of ` `// jumps to reach arr[n-1] from arr ` `int` `minJumps(``int` `arr[], ``int` `n) ` `{ ` `    ``// jumps[n-1] will hold the result ` `    ``int` `jumps[n]; ` `    ``int` `i, j; ` ` `  `    ``if` `(n == 0 || arr == 0) ` `        ``return` `INT_MAX; ` ` `  `    ``jumps = 0; ` ` `  `    ``// Find the minimum number of ` `    ``// jumps to reach arr[i] ` `    ``// from arr, 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, 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

 `// JAVA Code for Minimum number ` `// of jumps to reach end ` `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, 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

 `# Python3 program to find Minimum  ` `# number of jumps to reach end ` ` `  `# Returns minimum number of jumps ` `# to reach arr[n-1] from arr ` `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 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``, ``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#

 `// 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) ` ` `  `            ``// end cannot be reached ` `            ``return` `int``.MaxValue; ` ` `  `        ``jumps = 0; ` ` `  `        ``// Find the minimum number of ` `        ``// jumps to reach arr[i] ` `        ``// from arr, 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

 ` `

Output:

`Minimum number of jumps to reach end is 3`

Thanks to paras for suggesting this method.
Time Complexity: O(n^2)

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 arr.

## C++

 `// CPP program to find Minimum ` `// number of jumps to reach end ` `#include ` `using` `namespace` `std; ` ` `  `// Returns Minimum number of ` `// jumps to reach end ` `int` `minJumps(``int` `arr[], ``int` `n) ` `{ ` `    ``// jumps 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 direcly 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; ` `} ` ` `  `// Driver program to test above function ` `int` `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; ` `} `

## 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 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 direcly 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 mits. `

## Python3

 `# Python3 progrma to find Minimum  ` `# number of jumps to reach end ` ` `  `# Returns Minimum number of ` `# jumps to reach end ` `def` `minJumps(arr, n): ` `     `  `    ``# jumps 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 reachavle 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``, ``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#

 `// 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 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 direcly 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; ` `    ``} ` ` `  `    ``// 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

 `= 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 direcly 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``; ` `} ` ` `  `// 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. ` `?> `

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.

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

My Personal Notes arrow_drop_up

Article Tags :

39

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.