leetcode题：45. 跳跃游戏 II（困难）

一、题目描述

给定一个非负整数数组，你最初位于数组的第一个位置。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

你的目标是使用最少的跳跃次数到达数组的最后一个位置。

示例:

输入: [2,3,1,1,4]
输出: 2
解释: 跳到最后一个位置的最小跳跃数是 2。
     从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。
说明:

假设你总是可以到达数组的最后一个位置。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/jump-game-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、解题思路

方法一、动态规划，

1、建立数组dp保存从初始位置走到当前位置的最小步数。

2、min_right表示从min_pre 开始走的最大步数（如果当前位置i小于min_right的话，说明可以从min_pre再走一步就可以到达当前位置了。然后dp[i] = min（dp[i],dp[min_pre])就是走到当前位置的最小值。）

3、max_right记录从min_pre到min_right之间可以走的最右侧距离（即如果max_right < nums[i] + i则max_right = nums[i]+i,max_pre = i).

4、当i > min_right的时候，说明从min_pre已经不能一步走到i的位置了，此时更新min_right = max_right,min_pre = max_pre。保证min_pre,到min_right之间的点i都能从min_pre一步走到i的位置。

同时更新dp[nums[i]+i] = min(dp[min_pre]+1,dp[nums[i]+i])。

方法二、

LeetCode 讨论里，大部分都是这个思路，贪婪算法，我们每次在可跳范围内选择可以使得跳的更远的位置。

如下图，开始的位置是 2，可跳的范围是橙色的。然后因为 3 可以跳的更远，所以跳到 3 的位置。

写代码的话，我们用 end 表示当前能跳的边界，对于上边第一个图的橙色 1，第二个图中就是橙色的 4，遍历数组的时候，到了边界，我们就重新更新新的边界。

这里要注意一个细节，就是 for 循环中，i < nums.length - 1，少了末尾。因为开始的时候边界是第 00 个位置，steps 已经加 11 了。如下图，如果最后一步刚好跳到了末尾，此时 steps 其实不用加 11 了。如果是 i < nums.length，i 遍历到最后的时候，会进入 if 语句中，steps会多加 11。

方法三、

我们知道最终要到达最后一个位置，然后我们找前一个位置，遍历数组，找到能到达它的位置，离它最远的就是要找的位置。然后继续找上上个位置，最后到了第 0 个位置就结束了。

至于离它最远的位置，其实我们从左到右遍历数组，第一个满足的位置就是我们要找的。

 

三、代码

class Solution {
public:
    int jump(vector<int>& nums) {
        int len = nums.size();
        if(len == 0 )
            return len;
        vector<int> dp(len,INT_MAX);
        dp[0] = 0;
        int min_right = 0;
        int max_right = 0;
        int max_pre = 0;
        int min_pre = 0;
        for(int i = 0; i < len; i++)
        {
            int left = i;
            int right_tmp = nums[i] + i;
            right_tmp = min(right_tmp,len - 1);
            if(right_tmp > max_right)
            {
                max_right = right_tmp;
                max_pre = i;
            }
            if(left < min_right)
            {
                dp[left] = min(dp[left],dp[min_pre] + 1);
            }
            else
            {
                dp[left] = min(dp[left],dp[min_pre] + 1);
                min_pre = max_pre;
                min_right = max_right;
            }
            dp[right_tmp] = min(dp[right_tmp],dp[left] + 1);
            
        }
        //print(dp);
        return dp[len - 1];
    }
    void print(vector<int> & dp)
    {
        for(int i = 0;i<dp.size();i++)
        {
            cout<<dp[i]<<",";
        }
        cout<<endl;
    }

};

方法二、代码

public int jump(int[] nums) {
    int end = 0;
    int maxPosition = 0; 
    int steps = 0;
    for(int i = 0; i < nums.length - 1; i++){
        //找能跳的最远的
        maxPosition = Math.max(maxPosition, nums[i] + i); 
        if( i == end){ //遇到边界，就更新边界，并且步数加一
            end = maxPosition;
            steps++;
        }
    }
    return steps;
}

方法三、代码

public int jump(int[] nums) {
    int position = nums.length - 1; //要找的位置
    int steps = 0;
    while (position != 0) { //是否到了第 0 个位置
        for (int i = 0; i < position; i++) {
            if (nums[i] >= position - i) {
                position = i; //更新要找的位置
                steps++;
                break;
            }
        }
    }
    return steps;
}