**Objective**: Given an array of non negative integers, start from the first element and reach the last by jumping. The jump length can be at most the value at the current position in the array. Optimum result is when you reach the goal in minimum number of jumps.

**Example:**

Given array A = {2,3,1,1,4} possible ways to reach the end (index list) i) 0,2,3,4 (jump 2 to index 2, then jump 1 to index 3 then 1 to index 4) ii) 0,1,4 (jump 1 to index 1, then jump 3 to index 4) Since second solution has only 2 jumps it is the optimum result.

**Approach**:

**Recursion-**

- Start from the index 0. Try out each option.
- If the value at current index is ‘k’, then try out all the jumps from 1 to k.
- Each time you jump to new index. Follow the step 2 recursively.
- Base cases are –
- Check if you start index and end index are same then no further jumps are required, return 0.
- If value on the start index is 0, then we can pass through that index, return Integer.Max
- Calculate the remaining Length in the array which is yet to be travelled. If remaining length is less than the value at the present index then we do not need further recursion, we can reach to the destination in one jump so return 1.

**Code:**

**Dynamic Programming- Top Down**

If we look closely the diagram above we are solving many sub problems recursively. Here we will use Top-down approach of dynamic programming. We will use Hash Map to store the sub problems results and whenever we make a recursive call, first check if the sub problem is already solved, if yes then use it.

**Code**:

**Output**:

Minimum Jumps required: 9 Dynamic Programming - Time taken: 0 miliseconds

// Non recursive DP

public static int jumpsDP(int[] array){

int[] dp = new int[array.length];

dp[0]=0;

for(int i=1;i<array.length;i++){

dp[i] = Integer.MAX_VALUE;

}

for(int k=0;k<array.length;k++){

for(int i = 1;i<=array[k] && k+i <array.length;i++){

dp[k+i]= Math.min(dp[k+i], dp[k]+1);

}

}

return dp[array.length-1];

}