C 解法, 执行用时: 16ms, 内存消耗: 2888KB, 提交时间: 2022-02-25

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param nums int整型一维数组 
 * @param numsLen int nums数组长度
 * @return int整型
 *
 * C语言声明定义全局变量请加上static，防止重复定义
 */
int minJumpStep(int* nums, int numsLen ) {
    // write code here
    if (numsLen == 0) {
        return -1;
    }
    if (numsLen == 1) {
        return 0;
    }
    int farestReach = 0;//能够达到的最远位置
    int end = 0;		//跳跃范围的终点
    int step = 0;		//跳跃次数
    for (int i = 0; i < numsLen; i++) {
        farestReach = fmax(farestReach, nums[i] + i);
        if (i == end) {
            if (end == numsLen - 1)
                break;
            else {
                if (farestReach == end)
                    return -1;
                end = farestReach;
                step++;
            }
            if(farestReach >= numsLen - 1)
                break;
        }
    }
    return step;
}

C 解法, 执行用时: 17ms, 内存消耗: 2884KB, 提交时间: 2022-04-17

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param nums int整型一维数组 
 * @param numsLen int nums数组长度
 * @return int整型
 *
 * C语言声明定义全局变量请加上static，防止重复定义
 */
#include <limits.h>
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
int minJumpStep(int* nums, int numsLen ) {
    // write code here
/*
    int next = 0;
    int cnt = 0;
    if (numsLen <= 1) {
        return numsLen - 1;
    }
    int max = nums[0];
    next = nums[0];
    for (int i = 1; i < numsLen; i++) {
        if (i > next) {
            cnt = -1;
            break;
        }
        if (i == next) {
            if (max == i) {
                cnt += 1;
            } else {
                cnt += 2;
            }
            max = i + nums[i];
        }
        next = MAX(next, i + nums[i]);
    }
    
    return cnt;
*/
    if (numsLen <= 1) {
        return numsLen - 1;
    }
    int cur = 0, next = nums[0];
    int cnt = 0;
    for (int i = 0; i <= next; i++) {
        next = MAX(next, i + nums[i]);
        if (i == cur) {
            cur = next;
            cnt++;
        }
        if (cur >= numsLen - 1) {
            return cnt;
        }
    }
    return -1;
}

C++ 解法, 执行用时: 17ms, 内存消耗: 3096KB, 提交时间: 2022-02-21

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param nums int整型vector 
     * @return int整型
     */
    int minJumpStep(vector<int>& nums) {
        // write code here
        int n = nums.size();
        int count = 0;
        if (n == 0) return -1;
        if (n == 1) return 0;
        int currMaxIndex = 0, nextMaxIndex = nums[0];
        for (int i = 0; i <= nextMaxIndex; i++) {
            nums[i] = i + nums[i];
            nextMaxIndex = max(nextMaxIndex, nums[i]);
            if (i == currMaxIndex) {
                currMaxIndex = nextMaxIndex;
                count++;
            }
            if (currMaxIndex >= n - 1) {
                return count;
            }
        }
        return -1;
    }
};

C++ 解法, 执行用时: 18ms, 内存消耗: 3000KB, 提交时间: 2022-05-31

class Solution {
  public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     *
     * @param nums int整型vector
     * @return int整型
     */
    int minJumpStep(vector<int>& nums) {
        // write code here
        int len = nums.size();
//         获取数组长度
        if (len == 0) return -1;
//         如果是 0 按照题意返回 -1
        if (len == 1) return 0;
//         如果是 1 那么我们直接可以返回 0
        int pos = nums[0], end = nums[0], step = 1;
//         我们把可以目前区间内可以到达的最远距离设置为我们第 0 个的可以跳的距离
//         然后我们第一次的边界也是我们第 0 个可以跳的最远距离
//         因为我们这时候数组至少有两个及以上的元素，我们可以直接算是跳了一步
        for (int i = 1; i < len - 1; i++) {
//             我们从 1 开始遍历到我们最后一个元素前面的一个元素，这个在前面解析中有
            if (pos >= i) {
//                 如果我们的可以到达的最终位置大于等于当前位置我们继续
                pos = max(pos, i + nums[i]);
//                 每次获取最大值
                if (end == i) end = pos, step++;
//                 如果已经到达了我们的边界，我们更新我们的边界值，然后把我们的步数加 1
            }
        }
        if (end < len - 1) return -1;
//         如果最后我们的边界值没有到达我们的最后一个元素的位置，我们返回 -1
        return step;
    }
};

C++ 解法, 执行用时: 18ms, 内存消耗: 3000KB, 提交时间: 2022-01-18

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param nums int整型vector 
     * @return int整型
     */
    int minJumpStep(vector<int>& nums) {
        // write code here
        int len=nums.size();
        if(len==0)
            return -1;
        if(len==1)
            return 0;
        int pos=nums[0],end=nums[0],step=1;
        for(int i=1;i<len-1;i++)
        {
            if(pos>=i)
            {
                pos=max(pos,i+nums[i]);
                if(end==i)
                    end=pos,step++;
            }
        }
        if(end<len-1)
            return -1;
        return step;
    }
};