跳跃游戏

跳跃游戏

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

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

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

示例 1:

输入: [2,3,1,1,4]输出: true解释: 我们可以先跳 1 步，从位置 0 到达 位置 1, 然后再从位置 1 跳 3 步到达最后一个位置

示例 2:

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

方法一：递归(超时)

public boolean canJump(int[] nums) {
    return dfs(nums, 0);
}

public boolean dfs(int[] nums, int pos) {
    if (pos >= nums.length - 1) {//应该是>=，因为可能跳过了最后一个位置
        return true;
    }
    for (int i = 1; i <= nums[pos]; i++) {
        if (dfs(nums, pos + i)) {
            return true;
        }
    }
    return false;
}

方法二：记忆优化

public boolean canJump(int[] nums) {
    int[] dp = new int[nums.length - 1];
    return dfs(nums, 0, dp);
}

public boolean dfs(int[] nums, int pos, int[] dp) {
    if (pos >= nums.length - 1) {
        return true;
    }
    if (dp[pos] != 0) {
        return dp[pos] == 1;
    }
    for (int i = 1; i <= nums[pos]; i++) {
        if (dfs(nums, pos + i, dp)) {
            dp[pos] = 1;
            return true;
        }
    }
    dp[pos] = -1;
    return false;
}

贪心：方法三：可以到达最远位置
在遍历数组过程中，依次记录能到达的最远位置，如果i大于能到达的最远位置，说明不能达到i，返回false

public boolean canJump(int[] nums) {
    int maxReach=0;
    for(int i = 0; i < nums.length; i++){
        if(i > maxReach) return false;
        maxReach = Math.max(maxReach, i + nums[i]);
        if(maxReach >= nums.length - 1) break;//小优化：已经判断出可以跳到末尾，直接退出
    }
    return true;
}

方法四：最早开始位置
从后开始往前遍历，记录能达到最后一个位置的最早开始位置

public boolean canJump(int[] nums) {
    int last = nums.length - 1;
    for(int i = nums.length - 2; i >= 0; i--){
        if(i + nums[i] >= last){
            last = i;
        }
    }
    return last == 0;
}

跳跃游戏 II

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

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

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

示例:

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

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

方法一：dfs(超时)

private int minStep;

public int jump(int[] nums) {
    minStep = nums.length - 1;
    dfs(nums, 0, 0);
    return minStep;
}

public void dfs(int[] nums, int pos, int step) {
    if (pos >= nums.length - 1) {
        minStep = Math.min(minStep, step);
        return;
    }
    for (int i = 1; i <= nums[pos]; i++) {
        dfs(nums, pos + i, step + 1);
    }
}

方法二：反向查找出发位置
我们的目标是到达数组的最后一个位置，因此我们可以考虑最后一步跳跃前所在的位置，该位置通过跳跃能够到达最后一个位置。

如果有多个位置通过跳跃都能够到达最后一个位置，那么我们应该如何进行选择呢？直观上来看，我们可以「贪心」地选择距离最后一个位置最远的那个位置，也就是对应下标最小的那个位置。因此，我们可以从左到右遍历数组，选择第一个满足要求的位置。

找到最后一步跳跃前所在的位置之后，我们继续贪心地寻找倒数第二步跳跃前所在的位置，以此类推，直到找到数组的开始位置。

public int jump(int[] nums) {
    int step = 0;
    int pos = nums.length - 1;
    while (pos > 0){
        for (int i = 0; i < pos; i++) {
            if(i + nums[i] >= pos){
                pos = i;
                step++;
                break;
            }
        }
    }
    return step;
}

时间复杂度O(n²)

方法三：正向查找可到达的最大位置
维护当前能够到达的最大下标位置，记为边界end。我们从左到右遍历数组，到达边界时，更新边界并将跳跃次数增加 1。

把从nums[0]能到达的最远距离看成一段，遍历此段中的内容，以找到从此段中出发可以到达的最远距离，一直遍历到此段的最后一位，再跳到之前找到的最远距离。

跳后，上一段的最后一位成为下一段的开始，继续遍历。

由于段与段是链接的，直接遍历nums即可完成对段的遍历。

也可以以图形的方法形象的想一下，方便理解。

思想大约是当前每段的最优解，即总体最优解。

public int jump(int[] nums) {
    int step = 0;
    int maxPos = 0;
    int end = 0;
    for (int i = 0; i < nums.length - 1; i++) {
        maxPos = Math.max(maxPos, i + nums[i]);
        if (i == end) {
            end = maxPos;
            step++;
        }
    }
    return step;
}

时间复杂度O(n)

跳跃游戏 III

这里有一个非负整数数组 arr，你最开始位于该数组的起始下标 start 处。当你位于下标 i 处时，你可以跳到 i + arr[i] 或者 i - arr[i]。

请你判断自己是否能够跳到对应元素值为 0 的 任意 下标处。

注意，不管是什么情况下，你都无法跳到数组之外。

示例 1：

输入：arr = [4,2,3,0,3,1,2], start = 5输出：true解释：
到达值为 0 的下标 3 有以下可能方案：
下标 5 -> 下标 4 -> 下标 1 -> 下标 3
下标 5 -> 下标 6 -> 下标 4 -> 下标 1 -> 下标 3

示例 2：

输入：arr = [4,2,3,0,3,1,2], start = 0输出：true解释： 到达值为 0 的下标 3 有以下可能方案：
下标 0 -> 下标 4 -> 下标 1 -> 下标 3

示例 3：

输入：arr = [3,0,2,1,2], start = 2输出：false解释：无法到达值为 0 的下标 1 处。

提示：

• 1 <= arr.length <= 5 * 10^4
• 0 <= arr[i] < arr.length
• 0 <= start < arr.length

方法一：DFS
如果跳到了已经到过的位置，说明这个位置不能跳，回退到上一步

public boolean canReach(int[] arr, int start) {
    return dfs(arr, start, new boolean[arr.length]);
}

public boolean dfs(int[] arr, int i, boolean[] used) {
    if (used[i]) {
        return false;
    }
    if (arr[i] == 0) {
        return true;
    }
    used[i] = true;
    return i + arr[i] < arr.length && dfs(arr, i + arr[i], used)
        || i - arr[i] >= 0 && dfs(arr, i - arr[i], used);
}

时间复杂度O(n)

方法二：BFS

public boolean canReach(int[] arr, int start) {
    boolean[] used = new boolean[arr.length];
    Queue<Integer> queue = new LinkedList<>();
    queue.offer(start);
    while (!queue.isEmpty()) {
        int pos = queue.poll();
        used[pos] = true;
        if (arr[pos] == 0) {
            return true;
        }
        if (arr[pos] + pos < arr.length && !used[pos + arr[pos]]) {
            queue.offer(arr[pos] + pos);
        }
        if (pos - arr[pos] >= 0 && !used[pos - arr[pos]]) {
            queue.offer(pos - arr[pos]);
        }
    }
    return false;
}

时间复杂度O(n)