GeeksforGeeks App
Open App
Browser
Continue

# Minimum number of jumps to reach end

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.

Recommended Practice

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

 ``

## Javascript

 ``

Output

`Minimum number of jumps to reach the end is 3`

Time complexity: O(nNn).

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

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

 ``

## Javascript

 ``

Output

`Minimum number of jumps to reach end is 3`

Thanks to paras for suggesting this method.

Time Complexity: O(n2
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 ``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 ``#include ` `// 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

 `= 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

 ``

Output

`Minimum number of jumps to reach end is 3`

Time complexity: O(n2). 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 the end using  Greedy Algorithms:

### Algorithm:

Here’s the step-by-step algorithm.

•  If the array ‘arr[ ]’ contains only one element or is empty, we have reached the end of the array with 0 jumps. Return 0
•   If the first element array arr is 0, we can’t move forward. Return -1.
•  Initialize ‘maxReach’ as the first element of the array arr, ‘steps’ as the first element of the array, and ‘jumps’ as 1.
i.e.
int maxReach = arr[0];
int steps = arr[0];  and,
int jumps = 1;
•  Traverse the array ‘arr’ from the second element of the array to the last element:
•  If we have reached the last element of the array arr[ ], return the number of ‘jumps’ taken so far.
•  Modify the maximum index that can be reached with the current jump to the sum of the current index and the number of steps that can be taken from the current index.
• Reduce the number of steps left from the current index.
•  If the number of steps remaining from the current index reaches 0, increase the number of ‘jumps’ made thus far and update the number of steps that can be taken from the current index as the difference between the updated ‘maxReach’ and the current index.
• If the current index is greater than or equal to the maximum index that can be reached, return -1.
•  If we haven’t reached the end of the array ‘arr [ ]’ after iterating through out all the elements, it means we can’t reach the end of the array. Return -1.

Here is the implementation of the above algorithm.

## C++

 `#include ``using` `namespace` `std;` `int` `minJumps(``int` `arr[], ``int` `n)``{``    ``if` `(n <= 1) ``// If there is only one element or the array``                ``// is empty, we have reached the end of the``                ``// array with 0 jumps``        ``return` `0;``    ``if` `(arr[0] == 0) ``// If the first element is 0, we can't``                     ``// move forward``        ``return` `-1;` `    ``int` `maxReach``        ``= arr[0]; ``// Stores the maximum index that can be``                  ``// reached with the current jump``    ``int` `steps``        ``= arr[0]; ``// Stores the number of steps that can be``                  ``// taken from the current index``    ``int` `jumps``        ``= 1; ``// Stores the number of jumps taken so far` `    ``for` `(``int` `i = 1; i < n; i++) {``        ``if` `(i == n - 1) ``// If we have reached the end of the``                        ``// array, return the number of jumps``                        ``// taken so far``            ``return` `jumps;``        ``maxReach``            ``= max(maxReach,``                  ``i + arr[i]); ``// Update the maximum index``                               ``// that can be reached with``                               ``// the current jump``        ``steps--; ``// Decrement the number of steps that can``                 ``// be taken from the current index``        ``if` `(steps == 0) { ``// If no more steps can be taken``                          ``// from the current index, we need``                          ``// to take another jump``            ``jumps++; ``// Increment the number of jumps taken``                     ``// so far``            ``if` `(i >= maxReach) ``// If the current index is``                               ``// greater than the maximum``                               ``// index that can be reached,``                               ``// return -1``                ``return` `-1;``            ``steps = maxReach - i; ``// Update the number of``                                  ``// steps that can be taken``                                  ``// from the current index``        ``}``    ``}``    ``return` `-1; ``// If we haven't reached the end of the``               ``// array, return -1``}` `int` `main()``{``    ``int` `n = 11;``    ``int` `arr[] = { 1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9 };``    ``cout << minJumps(arr, n) << endl;` `    ``return` `0;``}` `// This code is contributed by Vaibhav Saroj`

Output

`3`

Time complexity: O(n).
Auxiliary Space: O(1).

## Minimum number of jumps to reach the end using Using Top Down Approach(Memoization):

Intuition:
We have to climb stairs with minimum steps, this question reminds us of min cost hill climbing but with steps as cost.

Approach:
if we break down this question then it’s very simple.
first think what you will do if you found out your self in this question.
first climb 1st step with 0 step.
then see how far you can jump, and go to next all possible jumping steps only if when you jump on some x stairs remeber the minimum jump on that stairs and if it’s greater from current jump then only we will replace it with our current jump.
that’s it we found our minimum cost of step.
Iterate over, 1 to length of nums.
put memo[0]=0memo[0] = 0memo[0]=0, because we’re placed in first step from start.
now check form next step.
if jumping to next step is low cost then it already is, replace it with minimum steps, memo[j]>memo[i]+1memo[j] > memo[i]+1memo[j]>memo[i]+1 this takes care of it.
now return memo[n−1]memo[n-1]memo[n−1].

## C++

 `#include ``using` `namespace` `std;` ` ``int` `jump(vector<``int``>& nums, ``int` `idx, ``int` `end, vector<``int``>& memo) {``        ` `        ``//we reached the end. No jumps to make further``        ``if` `(idx == end)``            ``return` `0;``        ` `        ``if` `(memo[idx] != -1)``            ``return` `memo[idx];``        ` `        ``int` `min_jumps = INT_MAX - 1;``        ` `        ``//we will try to make all possible jumps from current index``        ``//and select the minimum of those``        ``//It does not matter if we try from 1 to nums[idx]``        ``//or from nums[idx] to 1``        ``for` `(``int` `j = nums[idx]; j >= 1; --j) {``            ``//If we make this jump 'j' distance away from idx``            ``//do we overshoot?``            ``//if we land within the nums, we will test further``            ``if` `(idx + j <= end) {``                ``//Make a jump to idx + j index and explore further``                ``//then update min_jumps with the minimum jumps``                ``//we made to reach end while trying all possible``                ``//nums[idx] jumps from current index.``                ``min_jumps = std::min(min_jumps, 1 + jump(nums, idx + j, end, memo));``            ``}``        ``}``        ` `        ``return` `memo[idx] = min_jumps;``    ``}``    ` `    ``//Memoization``    ``int` `minJumps(vector<``int``>& nums) {``        ``vector<``int``> memo(nums.size(), -1);``        ``return` `jump(nums, 0, nums.size() - 1, memo);``    ``}`  `int` `main()``{``    ``int` `n = 11;``    ``vector<``int``> arr{ 1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9 };``    ``cout << minJumps(arr) << endl;` `    ``return` `0;``}` `// This code is contributed by Tushar Seth`

Output

```3
```

Time complexity: O(n) with memoisation as we calculate each path only once and O(n^2) is no memoisation.

Auxiliary Space: O(n) as we keep path jumps of each position in array or O(1) we do not allocate extra space except for memoisation.

Minimum number of jumps to reach end | Set 2 (O(n) solution)
Thanks to Ashish for suggesting this solution.