Leetcode【贪心】| 45. 跳跃游戏 II

题目

给定一个非负整数数组，你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
你的目标是使用最少的跳跃次数到达数组的最后一个位置。
示例:
　输入: [2,3,1,1,4]
　输出: 2
解释: 跳到最后一个位置的最小跳跃数是 2。从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。
说明: 假设你总是可以到达数组的最后一个位置。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/jump-game-ii

解题

反着找（动态规划）

 从终点开始，先求出能一步跳到终点n-1的位置i，此时i+nums[i]>=n-1，然后再求出能到达 i 的位置j（j+nums[j] >= i）此时将i当成终点就可用递归实现，这样一步步往前推，直到推到第一个位置，每推一步步数+1。将所有情况列出，求出步数最小的一个res。

图解举例：以nums = {2,3,1,1,4}为例

1. 倒数第一步：从终点位置4开始，从位置0(2)，位置1(3)，位置2(1)，位置3(1)依次遍历，能到达位置4的有位置1(3：1+3>=4)和位置3(1：3+1>=4)。
   
2. 倒数第二步：将位置1/位置3作为终点再次往前推一步。
   ① 位置1为终点：从位置0开始遍历，能到位置1的有位置0（0+2 >= 1）。推到了第一个位置，循环结束，总共只需两步，res=2。
   
   ② 位置3为终点：从位置0开始遍历，能到达位置3的有位置1（1+3>= 3）、位置2（2+1>=3），这里还没有到第一个位置，所以需要再往前推一步。
   
   倒数第三步：能到达位置1的有位置0(0+2>=1)，能到达位置2的有位置0(0+2>=2)，此时到达第一个位置，总共需要三部，res=3。
   
   

 通过枚举出所有情况，可得resmin = 2。

递归实现如下：枚举所有情况求步数最小的，这样会超时。

//left始终为0,right为每次的终点i,第一个终点是
 		for(int i = left; i < right; i++){
            if(farthest[i]>=right){//farthest[i] = i+nums[i]
                res = Math.min(res,jumpres(nums,0,i,farthest)+1);
            }
        }

优化：
 每次只需要求出从终点开始能一步跳到终点的最远的位置i，即从left开始遍历，求出的第一个farthest[i]>=right的i即可。
 从上述图解示例就可以看出，每次求能跳的最远的位置(即只求红色箭头,浅绿色箭头的都忽略不用枚举)，即离初始位置最近的位置，其实就是步数最少的选择，就不用把所有情况的res都求出来选出min，就不会超时了。

 优化代码如下:

		for(int i = left; i < right; i++){
            if(farthest[i]>=right){//farthest[i] = i+nums[i]
                res = jumpres(nums,0,i,farthest)+1;
                break;
            }
        }

递归实现

class Solution {
    int res = Integer.MAX_VALUE;
    public int jump(int[] nums) {
        int[] farthest = new int[nums.length];//每个点最远能到达的位置
        for(int i = 0; i < nums.length; i++){
            farthest[i] = i+nums[i];
        }
        return  jumpres(nums,0,nums.length-1,farthest);

    }
    public int jumpres(int[] nums, int left, int right, int[] farthest){
        int n = right-left+1;

        if(n < 2) return 0;
        //因为假设你总是可以到达数组的最后一个位置，所以当只有两个元素的时候不用判断直接返回1步到达。
        if(n == 2 || n <= nums[left]+left) return 1;
        for(int i = left; i < right; i++){
            if(farthest[i]>=right){
                res = jumpres(nums,0,i,farthest)+1;
                break;
            }
        }
        return res;
    }
}

非递归实现

参考这里

class Solution {   
	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;
	}
}

正着找（贪心算法）

思路

 与Leetcode【贪心】| 55. 跳跃游戏 不同的是，55题只需维护从初始位置开始每次跳能到达的最远位置farthest，看总最远位置是否能超过终点即可。而这一题假设肯定能跳到终点，但要求出步数，所以要维护从初始位置开始每一步能到达的最远位置，看总共需要几步。

 贪心选择：维护走每一步能到达的最远位置stepfar。

1. 当这一步能到达的最远位置已经超过终点时，就是能跳跃到终点的最少步数。
2. 若这一步能到达的最远位置没到终点的时候，要从这一步能到达的位置中选出一个位置进行下一步跳跃，让下一步能到达的位置最远，这时就需要和55题的跳跃游戏一样维护一个在当前位置之前能最远跳跃到的位置farthest = Math.max(farthest, i+nums[i])，当遍历到每一步的最远位置时更新下一步的最远位置使用。

图解举例：以nums = {2,3,1,1,4}为例

1. 第一步：从第一个位置走第一步，最远能到达 0+2 位置，所以2，3这三个位置都能到达。但并没有到达终点位置4，所以要进行第二步。
   

2. 第二步：在第一步能到达的区域（位置1，2）内，选择第二步能到达的最远的位置，很显然是位置1（1+3）> 位置2（2+1），第一个位置能到达的位置更远，为4>=终点4，表示到达终点了，最终结果，在此数组中最少两步就能到达终点。
   

Java实现

class Solution {   
    public int jump(int[] nums) {
        int res = 0;//走的步数
        int farthest = 0;//维护当前最远能到达的位置
        int stepfar = 0;//维护每一步能到达的最远位置
        int n = nums.length;
        if(n < 2) return 0;
        if(n == 2) return 1;
        for(int i = 0; i < n-1; i++){
            farthest = Math.max(farthest,i+nums[i]);
            if(stepfar >= n-1) return res;//当前这一步最远的位置已经到终点，则返回结果
            if(i == stepfar){//已经遍历到这一步能走到的最远的位置，但还没到终点，就要再走一步
                stepfar = farthest;//更新下一步能到达的最远的位置，即到目前为止之前所有元素最大的farthest
                res++;//走下一步，步数+1
            }
        }
        return  res;
    }
}