[Leetcode 100] 130 Jump Game II

Problem:

Given an array of non-negative integers, you are initially positioned at the first index of the array.

Each element in the array represents your maximum jump length at that position.

Your goal is to reach the last index in the minimum number of jumps.

For example:
Given array A = [2,3,1,1,4]

The minimum number of jumps to reach the last index is 2. (Jump 1 step from index 0 to 1, then 3 steps to the last index.)

Analysis:

At first thought, this problem can be solved by DP. Starting from the first position, for every reachable position from first position, copmare the current step with the step from first position to get to it and take the min one. Then continue this process at 2, 3, 4, ..... n position, at last the step[n-1] keeps the minimum steps needed to get from start to the end. But this method can't pass the large test case. One possible input is [1000, 999, 998, ....., 1], the conplexity is O(N^2). It's untorable.

So we have to think more simple ways to solve it. Every time we keep the maximum position we can go until now. And we still use an array to keep steps needed to get each position. But unlike the above method, if A[i]+i is less than maximum, we simply skip it. And if A[i]+i > maximum, we only set those [maximum+1, A[i]+i] positions step to step[i]+1. And if anytime we reach the end of the array, we exit the computing. This method is totally linear. After searching online, I know this method is called greedy method.

Code:

DP solution (TLE for large test)

class Solution {
public:
    int jump(int A[], int n) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        int *step = new int[n];
        int MAX = (1<<31)-1;
        
        for (int i=1; i<n; i++)
            step[i] = MAX;
        step[0] = 0;    
        
        for (int i=0; i<n; i++) {
            for (int j=1; j<=A[i] && (i+j)<n; j++) {
                step[i+j] = min(step[i]+1, step[i+j]);
            }
        }
        
        return step[n-1];
    }
    
private:
    int min(int a, int b) {
        return (a < b) ? a : b;
    }
};

Greedy Solution (48ms for large test)

class Solution {
public:
    int jump(int A[], int n) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        int max = 0;
        int *step = new int[n];
        
        step[0] = 0;
        for (int i=0; i<n; i++) {
            if (max >= (n-1)) break;

            if (max < (A[i] + i)) {
                for (int j=max+1; j<=A[i]+i && j < n; j++)
                    step[j] = step[i]+1;

                max = A[i] + i;
            }
        }
        
        return step[n-1];
    }
};