leetcode: Jump Game II

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.)

下面的这种解法尽管正确，但是超出了时间限制，因此需要考虑更优化的solution

class Solution {
public:
    
    //B[n] = min(B[k]+A[k];  k<n, A[k] >= n-k)

    int jump(int A[], int n) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        int *B = (int *)malloc(sizeof(int)*n);
        
        for (int idx = 0; idx < n; idx++)
        {
            B[idx] = 0;
        }
        
        for (int i = 1; i < n; i++)
        {
            int minStep = n;
            for (int j = 0; j < i; j++)
            {
                if (A[j] >= i-j)
                {
                    if (B[j]+1 < minStep)
                    {
                        minStep = B[j]+1;
                    }
                }
            }
            B[i] = minStep;
        }
        int ret = B[n-1];
        
        free(B);
        
        return ret;

    }
    
};

下面这种方法从队列尾开始，但是结果还是超出限制，看来不能用辅助数组的方法了

#define MIN_STEP 1000

class Solution {
public:
    int jump(int A[], int n) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if (A == NULL || n == 0)
            return 0;
        
        int ret;
        
        int *B = (int *)malloc(sizeof(int) * n);
        
        for (int idx = 0; idx < n; idx++)
            B[idx] = 0;
            
        for (int i = n-2; i >= 0; i--)
        {
            int minSteps    = MIN_STEP;
            int stepForward = A[i];
            for (int j = i+1; j <= n && stepForward > 0; j++, stepForward--)
            {
                if (B[j] < minSteps)
                {
                    minSteps = B[j];
                }
            }
            B[i] = minSteps+1;
        }
        
        ret = B[0];
        
        free(B);
          
        return ret;
    }
};

这是最后想出来的方法，时间复杂度满足要求

class Solution {
public:
    int jump(int A[], int n) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        if (A == NULL || n == 0 || n ==1)
            return 0;
            
        int idx          = 0;
        int beginIdx     = 0;
        int curMaxJumpIdx   = 0+A[0];
        int nextMaxJumpIdx;

        int jump = 1;

        while (curMaxJumpIdx < n-1)
        { 
            nextMaxJumpIdx = curMaxJumpIdx;
            for (idx = beginIdx+1; idx <= curMaxJumpIdx; idx++)
            {
                if (idx+A[idx] >= nextMaxJumpIdx)
                {
                    nextMaxJumpIdx = idx+A[idx];
                }
            }
            
            beginIdx = idx-1;
            curMaxJumpIdx = nextMaxJumpIdx != curMaxJumpIdx? nextMaxJumpIdx:beginIdx+A[beginIdx];
            
            jump++;
        }
        
        return jump;
    }
};