Linear time algorithm for Minimum number of jumps required to reach end

Question

Problem: 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, then we cannot move through that element.

Example:

Input: arr[] = {1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9} Output: 3 (1-> 3 -> 8 ->9) First element is 1, so can only go to 3. Second element is 3, so can make at most 3 steps i.e. to 5 or 8 or 9.

Source: http://www.geeksforgeeks.org/minimum-number-of-jumps-to-reach-end-of-a-given-array/

I have made a linear time algorithm for finding Minimum number of jumps required to reach end of an array.

The source code is as below:

int minJumpsUpdated(int arr[], int n)
{
  int *jumps = malloc(n * sizeof(int));  // jumps[n-1] will hold the result
  int i =1, j = 0;

  jumps[0] = 0;
  for (i = 1; i < n; ) { 

    // if i is out of range of arr[j], then increment j
    if (arr[j] + j < i && j < i) {

      j++;

    // else if i is within range of arr[j], 
    //   jumps for ith element would be jumps[j]+1
    } else if (arr[j] + j >= i && j < i) {

      jumps[i] = jumps[j] + 1;
      i++;

    } else {
      printf("solution does not exist");
      return -1;
    }
  }

  printf("jumps: ");
  for (i = 0; i < n; i++) {
    printf("%d, ", jumps[i]);
  }
  return jumps[n - 1];
}

Example:

1.) initially i=1, j=0 and arr[] = {1, 3, 6, 1, 0, 9};

jumps[] = 0,0,0,0,0,0

2.) as i is within range of arr[j] ie. i<= j+arr[j], number of jumps required to go to ith position would be min number of jumps till jth position + 1.

i=2, j=0, jumps[] = 0,1,0,0,0,0

3.) i>j+arr[j] i.e. j++;

i=2, j=1, jumps[] = 0,1,0,0,0,0

4.) i<=j+arr[j] i.e. jumps[i] = jumps[j]+1;

i=3, j=1, jumps[] = 0,1,2,0,0,0

5.) i<=j+arr[j] i.e. jumps[i] = jumps[j]+1;

i=4, j=1, jumps[] = 0,1,2,2,0,0

6.) i<=j+arr[j] i.e. jumps[i] = jumps[j]+1;

i=5, j=1, jumps[] = 0,1,2,2,2,0

7.) i>j+arr[j] i.e. j++;

i=5, j=2, jumps[] = 0,1,2,2,2,0

8.) i<=j+arr[j] i.e. jumps[i] = jumps[j]+1;

i=6, j=2, jumps[] = 0,1,2,2,2,3

------ END ------

I am not able to figure out under which test case this program will not work. I am asking this because on internet the optimized solution is using DP which is O(n^2). My solution is linear time. i.e. O(n). So I am assuming there are some cases which this algorithm will not handle. So I am curious what cases it does not handle.

Your help will be appreciated.

Thank you.

Answer 1

Summary of your algorithm:

1. Take the first item and look how far you can get with this
   (incrementing i until arr[j]+j < i)
2. Go to the next item that you can reach from the first one and that takes you at least to ith item.
3. Repeat this until you reach the last entry.

First:
Yes it runs in O(n) since the algorithm pushes both i an j only one time from 1 to n in worst case.

Second
I have not seen a proof that O(n²) is the optimal time-complexity.

Thrid
You can visualize the arr like this so this is exactly what your algorithm does. You can use this to proof by induction that your algorithm is correct. But as @Leo mentioned, there has to be a solution.

Fix for no-solution-case
Make sure that j < i holds.

Answer 2

I think your code is only correct if there is a solution, what if there is no solution for example what if the input is [0, 2 , 3 , 4] ?

Other than that I think your algorithm is correct, here is my solution when I solved this problem, it only need constant space, and still linear time. Basically for each step, you only jump to the position that could jump most steps in next step.

int jump(int A[], int n) {
    int jumps = 0;
    if(n < 2){
        return jumps;
    }
    int cur = 0; // current index,
    int cur_step;// number of step you can jump in current index 
    int last;    // last index
    int temp_max = cur; // temporary max jump distance 
    int temp_index = cur;// temporary index.

    while(cur < n){
        last = cur;
        cur_step = A[cur];
        if((cur + cur_step) >= n-1){ // if reached end of the array, return.
            jumps++;
            return jumps;
        }
        for(int ii = cur + 1; ii <= cur + cur_step; ii++){//go thru all the possible next position, and find the one that could jump most steps.
            if(A[ii] == 0){
                continue;
            }
            if(A[ii] + ii > temp_max){ // find the one that could jump most steps.
                temp_index = ii;
                temp_max = A[ii] + ii;
            }
        }
        cur = temp_index; // jump to this position, temp index holds index that jump most steps in next jump.
        if(cur != last){
            jumps++;
        }else{
            break;
        }
    }
    return -1;


}
};

Answer 3

Thank u for asking question and providing your code. Its a very simple and descent approach :). I have used your same approach and it has passed all the test cases in one of the coding platform. Providing below small code written in java which satisfy all test cases...

public int jump(ArrayList<Integer> a) {

    int dp[]=new int[a.size()];
    if(a.size()==1  || a.size() == 0)
        return 0;
    if(a.get(0)==0)
        return -1;
    Arrays.fill(dp,Integer.MAX_VALUE);      
    dp[0]=0;
    int j=0;
    for(int i=1;i<a.size() && j<a.size();)
    {
        if(j+a.get(j)>=i && dp[j]!=Integer.MAX_VALUE)
            {
                dp[i]=Math.min(dp[j]+1,dp[i]);
                i++;
            }
       else
            j++;
    }
    if(dp[a.size()-1]==Integer.MAX_VALUE)
        return -1;
   return dp[a.size()-1];     
}