# C# Program for Minimum number of jumps to reach end

Write a C# program for a given array arr[] where each element represents the maximum 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 an element is 0, then cannot move through that element.

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.

## C# Program for Minimum number of jumps to reach 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) = 1 + Min(minJumps(k, end)) for all k reachable from start.

Step-by-step approach:

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

Output

`Minimum number of jumps to reach end is 3`

Time complexity: O(nn). There are maximum n possible ways to move from an element. So the maximum number of steps can be nn.
Auxiliary Space: O(n). For recursion call stack.

## C# Program for Minimum number of jumps to reach end Using Dynamic Programming (Memoization):

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

Step-by-step approach:

• Create memo[] such that memo[i] indicates the minimum number of jumps needed to reach memo[n-1] from memo[i] to store previously solved subproblems.
• During the recursion call, if the same state is called more than once, then we can directly return the answer stored for that state instead of calculating again.
• Otherwise, 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.

Below is the implementation of the above approach:

## C#

 `using` `System;`   `class` `JumpGame {` `    ``// Recursive function to find minimum jumps required to` `    ``// reach the end` `    ``static` `int` `Jump(``int``[] nums, ``int` `idx, ``int` `end,` `                    ``int``[] memo)` `    ``{` `        ``// We reached the end, no more jumps needed` `        ``if` `(idx == end)` `            ``return` `0;`   `        ``// If memoization contains a value, return it` `        ``if` `(memo[idx] != -1)` `            ``return` `memo[idx];`   `        ``int` `minJumps = ``int``.MaxValue - 1;`   `        ``// Try all possible jumps from the current index` `        ``for` `(``int` `j = nums[idx]; j >= 1; j--) {` `            ``// Check if making the jump 'j' distance away` `            ``// from idx overshoots the end` `            ``if` `(idx + j <= end) {` `                ``// Make the jump to idx + j index and` `                ``// explore further Update minJumps with the` `                ``// minimum jumps to reach the end` `                ``minJumps = Math.Min(` `                    ``minJumps,` `                    ``1 + Jump(nums, idx + j, end, memo));` `            ``}` `        ``}`   `        ``// Memoize the result and return it` `        ``return` `memo[idx] = minJumps;` `    ``}`   `    ``// Memoization function to find minimum jumps` `    ``static` `int` `MinJumps(``int``[] nums)` `    ``{` `        ``int``[] memo = ``new` `int``[nums.Length];` `        ``Array.Fill(memo, -1);` `        ``return` `Jump(nums, 0, nums.Length - 1, memo);` `    ``}`   `    ``static` `void` `Main()` `    ``{` `        ``int``[] arr = { 1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9 };` `        ``Console.WriteLine(MinJumps(arr));` `    ``}` `}`

Output

```3
```

Time complexity: O(n2)
Auxiliary Space: O(n), because of recursive stack space and memo array.

## C# Program for Minimum number of jumps to reach end using Dynamic Programming (Tabulation):

Step-by-step approach:

• Create jumps[] array from left to right such that jumps[i] indicate the minimum number of jumps needed to reach arr[i] from arr.
• To fill the jumps array run a nested loop inner loop counter is 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# 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, 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`

Output

`Minimum number of jumps to reach end is 3`

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

Please refer complete article on Minimum number of jumps to reach end for more details!

Whether you're preparing for your first job interview or aiming to upskill in this ever-evolving tech landscape, GeeksforGeeks Courses are your key to success. We provide top-quality content at affordable prices, all geared towards accelerating your growth in a time-bound manner. Join the millions we've already empowered, and we're here to do the same for you. Don't miss out - check it out now!

Previous
Next