# Paths requiring minimum number of jumps to reach end of array

Given an array arr[], where each element represents the maximum number of steps that can be made forward from that element, the task is to print all possible paths that require the minimum number of jumps to reach the end of the given array starting from the first array element.

Note: If an element is 0, then there are no moves allowed from that element.

Examples:

Input: arr[] = {1, 1, 1, 1, 1}
Output:
0 1 2 3 4
Explanation:
In every step, only one jump is allowed.
Therefore, only one possible path exists to reach end of the array.

Input: arr[] = {3, 3, 0, 2, 1, 2, 4, 2, 0, 0}
Output:
0 3 5 6 9
0 3 5 7 9

Approach: The idea is to use Dynamic Programming to solve this problem. Follow the steps below to solve the problem:

• Initialize an array dp[] of size N, where dp[i] stores the minimum number of jumps required to reach the end of the array arr[N – 1] from the index i
• Compute the minimum number of steps required for each index to reach the end of the array by iterating over indices N – 2 to 1. For each index, try out all possible steps that can be taken from that index, i.e. [1, arr[i]].
• While trying out all the possible steps by iterating over [1, arr[i]], for each index, update and store the minimum value of dp[i + j].
• Initialize a queue of Pair class instance, which stores the index of the current position and the path that has been traveled so far to reach that index.
• Keep updating the minimum number of steps required and finally, print the paths corresponding to those required count of steps.

Below is the implementation of the above approach:

## C++

 // C++ program to implement the // above approach #include using namespace std;   // Pair Struct struct Pair {           // Stores the current index     int idx;       // Stores the path     // travelled so far     string psf;       // Stores the minimum jumps     // required to reach the     // last index from current index     int jmps; };   // Minimum jumps required to reach // end of the array void minJumps(int arr[], int dp[], int n) {     for(int i = 0; i < n; i++)         dp[i] = INT_MAX;       dp[n - 1] = 0;       for(int i = n - 2; i >= 0; i--)     {                   // Stores the maximum number         // of steps that can be taken         // from the current index         int steps = arr[i];         int min = INT_MAX;           for(int j = 1;                 j <= steps && i + j < n;                 j++)         {                           // Checking if index stays             // within bounds             if (dp[i + j] != INT_MAX &&                 dp[i + j] < min)             {                                   // Stores the minimum                 // number of jumps                 // required to jump                 // from (i + j)-th index                 min = dp[i + j];             }         }                   if (min != INT_MAX)             dp[i] = min + 1;     } }   // Function to find all possible // paths to reach end of array // requiring minimum number of steps void possiblePath(int arr[], int dp[], int n) {     queue Queue;     Pair p1 = { 0, "0", dp[0] };     Queue.push(p1);       while (Queue.size() > 0)     {         Pair tmp = Queue.front();         Queue.pop();           if (tmp.jmps == 0)         {             cout << tmp.psf << "\n";             continue;         }           for(int step = 1;                 step <= arr[tmp.idx];                 step++)         {             if (tmp.idx + step < n &&                 tmp.jmps - 1 == dp[tmp.idx + step])             {                                   // Storing the neighbours                 // of current index element                 string s1 = tmp.psf + " -> " +                  to_string((tmp.idx + step));                                    Pair p2 = { tmp.idx + step, s1,                            tmp.jmps - 1 };                                             Queue.push(p2);             }         }     } }   // Function to find the minimum steps // and corresponding paths to reach // end of an array void Solution(int arr[], int dp[], int size) {           // dp[] array stores the minimum jumps     // from each position to last position     minJumps(arr, dp, size);       possiblePath(arr, dp, size); }   // Driver Code int main() {     int arr[] = { 3, 3, 0, 2, 1,                   2, 4, 2, 0, 0 };       int size = sizeof(arr) / sizeof(arr[0]);     int dp[size];       Solution(arr, dp, size); }   // This code is contributed by akhilsaini

## Java

 // Java Program to implement the // above approach   import java.util.*; class GFG {       // Pair Class instance     public static class Pair {         // Stores the current index         int idx;           // Stores the path         // travelled so far         String psf;           // Stores the minimum jumps         // required to reach the         // last index from current index         int jmps;           // Constructor         Pair(int idx, String psf, int jmps)         {             this.idx = idx;             this.psf = psf;             this.jmps = jmps;         }     }       // Minimum jumps required to reach     // end of the array     public static int[] minJumps(int[] arr)     {         int dp[] = new int[arr.length];           Arrays.fill(dp, Integer.MAX_VALUE);           int n = dp.length;           dp[n - 1] = 0;           for (int i = n - 2; i >= 0; i--) {             // Stores the maximum number             // of steps that can be taken             // from the current index             int steps = arr[i];             int min = Integer.MAX_VALUE;               for (int j = 1; j <= steps && i + j < n; j++) {                 // Checking if index stays                 // within bounds                 if (dp[i + j] != Integer.MAX_VALUE                     && dp[i + j] < min) {                     // Stores the minimum                     // number of jumps                     // required to jump                     // from (i + j)-th index                     min = dp[i + j];                 }             }               if (min != Integer.MAX_VALUE)                 dp[i] = min + 1;         }         return dp;     }       // Function to find all possible     // paths to reach end of array     // requiring minimum number of steps     public static void possiblePath(         int[] arr, int[] dp)     {           Queue queue = new LinkedList<>();         queue.add(new Pair(0, "" + 0, dp[0]));           while (queue.size() > 0) {             Pair tmp = queue.remove();               if (tmp.jmps == 0) {                 System.out.println(tmp.psf);                 continue;             }               for (int step = 1;                  step <= arr[tmp.idx];                  step++) {                   if (tmp.idx + step < arr.length                     && tmp.jmps - 1 == dp[tmp.idx + step]) {                     // Storing the neighbours                     // of current index element                     queue.add(new Pair(                         tmp.idx + step,                         tmp.psf + " -> " + (tmp.idx + step),                         tmp.jmps - 1));                 }             }         }     }       // Function to find the minimum steps     // and corresponding paths to reach     // end of an array     public static void Solution(int arr[])     {         // Stores the minimum jumps from         // each position to last position         int dp[] = minJumps(arr);           possiblePath(arr, dp);     }       // Driver Code     public static void main(String[] args)     {         int[] arr = { 3, 3, 0, 2, 1,                       2, 4, 2, 0, 0 };         int size = arr.length;         Solution(arr);     } }

## Python3

 # Python3 program to implement the # above approach from queue import Queue import sys   # Pair Class instance class Pair(object):           # Stores the current index     idx = 0       # Stores the path     # travelled so far     psf = ""       # Stores the minimum jumps     # required to reach the     # last index from current index     jmps = 0       # Constructor     def __init__(self, idx, psf, jmps):                   self.idx = idx         self.psf = psf         self.jmps = jmps   # Minimum jumps required to reach # end of the array def minJumps(arr):       MAX_VALUE = sys.maxsize     dp = [MAX_VALUE for i in range(len(arr))]       n = len(dp)       dp[n - 1] = 0       for i in range(n - 2, -1, -1):                   # Stores the maximum number         # of steps that can be taken         # from the current index         steps = arr[i]         minimum = MAX_VALUE           for j in range(1, steps + 1, 1):             if i + j >= n:                 break                           # Checking if index stays             # within bounds             if ((dp[i + j] != MAX_VALUE) and                 (dp[i + j] < minimum)):                                       # Stores the minimum                 # number of jumps                 # required to jump                 # from (i + j)-th index                 minimum = dp[i + j]           if minimum != MAX_VALUE:             dp[i] = minimum + 1                   return dp   # Function to find all possible # paths to reach end of array # requiring minimum number of steps def possiblePath(arr, dp):       queue = Queue(maxsize = 0)     p1 = Pair(0, "0", dp[0])     queue.put(p1)       while queue.qsize() > 0:         tmp = queue.get()           if tmp.jmps == 0:             print(tmp.psf)             continue           for step in range(1, arr[tmp.idx] + 1, 1):             if ((tmp.idx + step < len(arr)) and                (tmp.jmps - 1 == dp[tmp.idx + step])):                                 # Storing the neighbours                 # of current index element                 p2 = Pair(tmp.idx + step, tmp.psf +                            " -> " + str((tmp.idx + step)),                          tmp.jmps - 1)                                            queue.put(p2)   # Function to find the minimum steps # and corresponding paths to reach # end of an array def Solution(arr):           # Stores the minimum jumps from     # each position to last position     dp = minJumps(arr)           possiblePath(arr, dp)   # Driver Code if __name__ == "__main__":           arr = [ 3, 3, 0, 2, 1,             2, 4, 2, 0, 0 ]     size = len(arr)       Solution(arr)   # This code is contributed by akhilsaini

## C#

 // C# program to implement the // above approach using System; using System.Collections;   // Pair Struct public struct Pair {           // Stores the current index     public int idx;       // Stores the path     // travelled so far     public string psf;       // Stores the minimum jumps     // required to reach the     // last index from current index     public int jmps;       // Constructor     public Pair(int idx, String psf, int jmps)     {         this.idx = idx;         this.psf = psf;         this.jmps = jmps;     } }   class GFG{   // Minimum jumps required to reach // end of the array public static int[] minJumps(int[] arr) {     int[] dp = new int[arr.Length];     int n = dp.Length;       for(int i = 0; i < n; i++)         dp[i] = int.MaxValue;       dp[n - 1] = 0;       for(int i = n - 2; i >= 0; i--)     {                   // Stores the maximum number         // of steps that can be taken         // from the current index         int steps = arr[i];         int min = int.MaxValue;           for(int j = 1;                 j <= steps && i + j < n;                 j++)         {                           // Checking if index stays             // within bounds             if (dp[i + j] != int.MaxValue &&                 dp[i + j] < min)             {                                   // Stores the minimum                 // number of jumps                 // required to jump                 // from (i + j)-th index                 min = dp[i + j];             }         }           if (min != int.MaxValue)             dp[i] = min + 1;     }     return dp; }   // Function to find all possible // paths to reach end of array // requiring minimum number of steps public static void possiblePath(int[] arr,                                 int[] dp) {     Queue queue = new Queue();     queue.Enqueue(new Pair(0, "0", dp[0]));       while (queue.Count > 0)     {         Pair tmp = (Pair)queue.Dequeue();           if (tmp.jmps == 0)         {             Console.WriteLine(tmp.psf);             continue;         }           for(int step = 1;                 step <= arr[tmp.idx];                 step++)         {             if (tmp.idx + step < arr.Length &&                tmp.jmps - 1 == dp[tmp.idx + step])             {                                   // Storing the neighbours                 // of current index element                   queue.Enqueue(new Pair(                     tmp.idx + step,                     tmp.psf + " -> " +                    (tmp.idx + step),                    tmp.jmps - 1));             }         }     } }   // Function to find the minimum steps // and corresponding paths to reach // end of an array public static void Solution(int[] arr) {           // Stores the minimum jumps from     // each position to last position     int[] dp = minJumps(arr);       possiblePath(arr, dp); }   // Driver Code static public void Main() {     int[] arr = { 3, 3, 0, 2, 1,                   2, 4, 2, 0, 0 };     int size = arr.Length;           Solution(arr); } }   // This code is contributed by akhilsaini

Output:

0 -> 3 -> 5 -> 6 -> 9
0 -> 3 -> 5 -> 7 -> 9

Time Complexity: O(N2)
Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : akhilsaini