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

思路：

接上面的Jump Game，在线性时间内可以解决能否到达的问题

再次注意，ma记录的是在当前位置所能到达的最远距离，这个ma是根据之前的所有最远距离得出的。

因此，如果A[i-j]能到的最远距离是X，那么A[i]能到的最远距离Y肯定不小于X，且从A[i]到达Y所需要的步数和A[i-j]到达X的步数相同。

因此这里维护一个长度相同的数组step，记录到达该index所用的最小步数，并在遍历过程中更新step信息。

返回step[n-1]即可。

这里注意更新step数组的时候，数组下标不要越界~

class Solution {
public:
    int jump(int A[], int n) {
        int ma = 0;
        int* step = new int[n];
        for(int i=0;i<n;i++)
            step[i] = 10000;
        step[0] = 0;
        for(int i=0;i<n;i++){
            ma = max(A[i],ma-1);
            if(ma+i<n){
                step[ma+i] = min(step[ma+i],step[i]+1);
            }else{
                step[n-1] = min(step[n-1],step[i]+1);
            }
        }
        return step[n-1];
    }
};

==================================================================

这是当时做题时候的想法。。。。。

在这里，这个判断很精髓

else{
   step[n-1] = min(step[n-1],step[i]+1);
}

这个判断可以保证求到达任一点的最小距离都能正确。(每求一个到达某一点的最小距离，都要进行一次这样的过程)

例如：

3 3 1 1 4

要求到达A[2]的最小步数

step一开始都是最大值

step[0] = 0

开始遍历：

由于A[0]=3,所以 step[3] = 1

 (这里，如果求得是到达A[2]的最小步数，那么那个判断条件就会有作用：ma+i  即3+0>(n-1)，那么到达A[2]的最小步数就是min(step[2], step[0]+1)，即值位1.)

===========================================

=====================================modified on 25th, March, 2014====================================

根据jump game的新的一种思路，来计算最短距离

记录当前能到的最远巨鹿ma

ma=max(ma,i+A[i])

然后T[ma] = min(T[ma],T[i]+1)  或者T[n-1] = min(T[n-1],T[i]+1)

class Solution {
public:
    const int MAX = 100000;
    int jump(int A[], int n) {
        int *T = new int[n];
        for(int i=0;i<n;i++)
            T[i] = MAX;
        T[0] = 0;
        int ma = 0;
        for(int i=0;i<n;i++){
            if(ma<i)
                return -1;
            ma = max(ma,i+A[i]);
            if(ma>=n)
                T[n-1] = min(T[n-1],T[i]+1);
            else
                T[ma] = min(T[ma],T[i]+1);
        }
        return T[n-1];
    }
};