跳跃游戏(jump-game)图解

跳跃游戏(jump-game)

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

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

判断你是否能够到达最后一个位置。

示例 1:

输入: [2,3,1,1,4]
输出: true
解释: 从位置 0 到 1 跳 1 步, 然后跳 3 步到达最后一个位置。

示例 2:

输入: [3,2,1,0,4]
输出: false
解释: 无论怎样，你总会到达索引为 3 的位置。
但该位置的最大跳跃长度是 0 ， 所以你永远不可能到达最后一个位置。

思路

从第 i 位置最远可以跳 nums[ i ] 步。
比如[2,3,1,1,4]
从0位置，最远可以跳两步;
从1位置，最远可以跳三步;
从2位置，最远可以跳一步;
从3位置，最远可以跳一步;
…
这样子无法直接看出规律，我们把最远跳多少步转化为可以跳跃到的位置。

我们把数组竖起来看一下规律。

数组	位置		1	2	3	4	5	6	7	8
2	0		O	O
3	1			O	O	O
1	2				O
1	3					O
4	4						O	O	O	O

从上面的表格可以看出
从第0位置，可以跳跃第1位置或第2位置;
从第1位置，可以跳跃第2、第3、第4位置;
从第2位置，可以跳跃第3位置;
从第3位置，可以跳跃第4位置;
…
所以，发现规律，从第 i 位置，最远可以跳至第 index[ i ] 位置。
i + nums[ i ] = index[ i ]。

思考，为什么只记录当前位置可以最远可以跳的位置，并把它们保存为一维数组，不用记录当前位置最近可以跳跃的位置吗？

代码

#include <stdio.h>

#include <vector>
class Solution {
public:
    bool canJump(std::vector<int>& nums) {
        std::vector<int> index; //最远可跳至的位置
        for (int i = 0; i < nums.size(); i++){
        	index.push_back(i + nums[i]);//计算index数组
        }
        int jump = 0; //jump指针
        int max_index = index[0]; //最远可以跳到的位置
        while(jump < index.size() && jump <= max_index){
        	if (max_index < index[jump]){
	        	max_index = index[jump]; //如果可以跳得更远，则更新max_index
	        }
        	jump++; //扫描jump
        }
        if (jump == index.size()){ //若jump到达数组尾部则返回真
        	return true;
        }
        return false; //否则返回假
    }
};

int main(){
	std::vector<int> nums;
	nums.push_back(2);
	nums.push_back(3);
	nums.push_back(1);
	nums.push_back(1);
	nums.push_back(4);
	Solution solve;
	printf("%d\n", solve.canJump(nums));
	return 0;
}

java

public class Solution {
    public boolean canJump(int[] nums) {
        int n = nums.length;
        int rightmost = 0;
        for (int i = 0; i < n; ++i) {
            if (i <= rightmost) {
                rightmost = Math.max(rightmost, i + nums[i]);
                if (rightmost >= n - 1) {
                    return true;
                }
            }
        }
        return false;
    }
}

python3

class Solution:
    def canJump(self, nums: List[int]) -> bool:
        n, rightmost = len(nums), 0
        for i in range(n):
            if i <= rightmost:
                rightmost = max(rightmost, i + nums[i])
                if rightmost >= n - 1:
                    return True
        return False

跳跃游戏II (jump-game-ii)

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

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

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

示例:

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

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

思路(正向查找可到达的最大位置)

在具体的实现中，我们维护当前能够到达的最大下标位置，记为边界。我们从左到右遍历数组，到达边界时，更新边界并将跳跃次数增加 1。

在遍历数组时，我们不访问最后一个元素，这是因为在访问最后一个元素之前，我们的边界一定大于等于最后一个位置，否则就无法跳到最后一个位置了。如果访问最后一个元素，在边界正好为最后一个位置的情况下，我们会增加一次「不必要的跳跃次数」，因此我们不必访问最后一个元素。

class Solution {
    public int jump(int[] nums) {
        int length = nums.length;
        int end = 0;//--------------边界
        int maxPosition = 0; //-----能跳到的最大下标位置
        int steps = 0;
        for (int i = 0; i < length - 1; i++) {
            maxPosition = Math.max(maxPosition, i + nums[i]); 
            if (i == end) {
                end = maxPosition;
                steps++;
            }
        }
        return steps;
    }
}

资料

参考leetcode-cn。