【力扣算法】55-跳跃游戏

最新推荐文章于 2023-08-07 17:35:34 发布

SquareSquareHe

最新推荐文章于 2023-08-07 17:35:34 发布

阅读量601

点赞数 1

分类专栏： java 文章标签： leetcode 算法 java 动态规划贪心算法

本文链接：https://blog.csdn.net/ZeromaXHe/article/details/90813757

版权

java 专栏收录该内容

180 篇文章 4 订阅

订阅专栏

题目

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

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

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

示例 1:

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

示例 2:

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

题解

定义

如果我们可以从数组中的某个位置跳到最后的位置，就称这个位置是“好坐标”，否则称为“坏坐标”。问题可以简化为第 0 个位置是不是“好坐标”。

题解

这是一个动态规划问题，通常解决并理解一个动态规划问题需要以下 4 个步骤：

利用递归回溯解决问题
利用记忆表优化（自顶向下的动态规划）
移除递归的部分（自底向上的动态规划）
使用技巧减少时间和空间复杂度

下面的所有解法都是正确的，但在时间和空间复杂度上有区别。

方法 1：回溯

这是一个低效的解决方法。我们模拟从第一个位置跳到最后位置的所有方案。从第一个位置开始，模拟所有可以跳到的位置，然后从当前位置重复上述操作，当没有办法继续跳的时候，就回溯。

public class Solution {
    public boolean canJumpFromPosition(int position, int[] nums) {
        if (position == nums.length - 1) {
            return true;
        }

        int furthestJump = Math.min(position + nums[position], nums.length - 1);
        for (int nextPosition = position + 1; nextPosition <= furthestJump; nextPosition++) {
            if (canJumpFromPosition(nextPosition, nums)) {
                return true;
            }
        }

        return false;
    }

    public boolean canJump(int[] nums) {
        return canJumpFromPosition(0, nums);
    }
}
作者：LeetCode
链接：https://leetcode-cn.com/problems/two-sum/solution/tiao-yue-you-xi-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

一个快速的优化方法是我们可以从右到左的检查 nextposition ，理论上最坏的时间复杂度复杂度是一样的。但实际情况下，对于一些简单场景，这个代码可能跑得更快一些。直觉上，就是我们每次选择最大的步数去跳跃，这样就可以更快的到达终点。

// Old
for (int nextPosition = position + 1; nextPosition <= furthestJump; nextPosition++)
// New
for (int nextPosition = furthestJump; nextPosition > position; nextPosition--)

比方说，对于下面的例子，我们从下标 0 开始跳，第一次跳到 1，第二次跳到 6。这样用 3 步就发现坐标 0 是一个“好坐标”。

Index 0 1 2 3 4 5 6
nums 1 5 2 1 0 2 0
下面的例子解释了上述优化没有办法解决的情况，坐标 6 是不能从任何地方跳到的，但是所有的方案组合都会被枚举尝试。

Index 0 1 2 3 4 5 6
nums 5 4 3 2 1 0 0
前几次回溯访问节点如下：0 -> 4 -> 5 -> 4 -> 0 -> 3 -> 5 -> 3 -> 4 -> 5 -> 等等。

复杂度分析

时间复杂度：O(2^n)，最多有 2^n 种从第一个位置到最后一个位置的跳跃方式，其中 n 是数组 nums 的元素个数，完整的证明见附录 A。
空间复杂度：O(n)，回溯法只需要栈的额外空间。

方法 2：自顶向下的动态规划

自顶向下的动态规划可以理解成回溯法的一种优化。我们发现当一个坐标已经被确定为好 / 坏之后，结果就不会改变了，这意味着我们可以记录这个结果，每次不用重新计算。

因此，对于数组中的每个位置，我们记录当前坐标是好 / 坏，记录在数组 memo 中，定义元素取值为 GOOD ，BAD，UNKNOWN。这种方法被称为记忆化。

例如，对于输入数组 nums = [2, 4, 2, 1, 0, 2, 0] 的记忆表如下，G 代表 GOOD，B 代表 BAD。我们发现不能从下标 2，3，4 到达最终坐标 6，但可以从 0，1，5 和 6 到达最终坐标 6。

Index 0 1 2 3 4 5 6
nums 2 4 2 1 0 2 0
memo G G B B B G G

步骤

初始化 memo 的所有元素为 UNKNOWN，除了最后一个显然是 GOOD （自己一定可以跳到自己）
优化递归算法，每步回溯前先检查这个位置是否计算过（当前值为：GOOD / BAD）
- 如果已知直接返回结果 True / False
- 否则按照之前的回溯步骤计算
计算完毕后，将结果存入memo表中

enum Index {
    GOOD, BAD, UNKNOWN
}

public class Solution {
    Index[] memo;

    public boolean canJumpFromPosition(int position, int[] nums) {
        if (memo[position] != Index.UNKNOWN) {
            return memo[position] == Index.GOOD ? true : false;
        }

        int furthestJump = Math.min(position + nums[position], nums.length - 1);
        for (int nextPosition = position + 1; nextPosition <= furthestJump; nextPosition++) {
            if (canJumpFromPosition(nextPosition, nums)) {
                memo[position] = Index.GOOD;
                return true;
            }
        }

        memo[position] = Index.BAD;
        return false;
    }

    public boolean canJump(int[] nums) {
        memo = new Index[nums.length];
        for (int i = 0; i < memo.length; i++) {
            memo[i] = Index.UNKNOWN;
        }
        memo[memo.length - 1] = Index.GOOD;
        return canJumpFromPosition(0, nums);
    }
}
作者：LeetCode
链接：https://leetcode-cn.com/problems/two-sum/solution/tiao-yue-you-xi-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

复杂度分析

时间复杂度：O(n^2)，数组中的每个元素，假设为 i，需要搜索右边相邻的 nums[i] 个元素查找是否有 GOOD 的坐标。 nums[i] 最多为 n，n 是 nums 数组的大小。
空间复杂度：O(2n)=O(n)，第一个 n 是栈空间的开销，第二个 n 是记忆表的开销。

方法 3：自底向上的动态规划

底向上和自顶向下动态规划的区别就是消除了回溯，在实际使用中，自底向下的方法有更好的时间效率因为我们不再需要栈空间，可以节省很多缓存开销。更重要的事，这可以让之后更有优化的空间。回溯通常是通过反转动态规划的步骤来实现的。

这是由于我们每次只会向右跳动，意味着如果我们从右边开始动态规划，每次查询右边节点的信息，都是已经计算过了的，不再需要额外的递归开销，因为我们每次在 memo 表中都可以找到结果。

enum Index {
    GOOD, BAD, UNKNOWN
}

public class Solution {
    public boolean canJump(int[] nums) {
        Index[] memo = new Index[nums.length];
        for (int i = 0; i < memo.length; i++) {
            memo[i] = Index.UNKNOWN;
        }
        memo[memo.length - 1] = Index.GOOD;

        for (int i = nums.length - 2; i >= 0; i--) {
            int furthestJump = Math.min(i + nums[i], nums.length - 1);
            for (int j = i + 1; j <= furthestJump; j++) {
                if (memo[j] == Index.GOOD) {
                    memo[i] = Index.GOOD;
                    break;
                }
            }
        }

        return memo[0] == Index.GOOD;
    }
}
作者：LeetCode
链接：https://leetcode-cn.com/problems/two-sum/solution/tiao-yue-you-xi-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

复杂度分析

时间复杂度：O(n^2)，数组中的每个元素，假设为 i，需要搜索右边相邻的 nums[i] 个元素查找是否有 GOOD 的坐标。 nums[i] 最多为 n，n 是 nums 数组的大小。
空间复杂度：O(n)，记忆表的存储开销。

方法 4：贪心

当我们把代码改成自底向上的模式，我们会有一个重要的发现，从某个位置出发，我们只需要找到第一个标记为 GOOD 的坐标（由跳出循环的条件可得），也就是说找到最左边的那个坐标。如果我们用一个单独的变量来记录最左边的 GOOD 位置，我们就可以避免搜索整个数组，进而可以省略整个 memo 数组。

从右向左迭代，对于每个节点我们检查是否存在一步跳跃可以到达 GOOD 的位置（currPosition + nums[currPosition] >= leftmostGoodIndex）。如果可以到达，当前位置也标记为 GOOD ，同时，这个位置将成为新的最左边的 GOOD 位置，一直重复到数组的开头，如果第一个坐标标记为 GOOD 意味着可以从第一个位置跳到最后的位置。

模拟一下这个操作，对于输入数组 nums = [9, 4, 2, 1, 0, 2, 0]，我们用 G 表示 GOOD，用 B 表示 BAD 和 U 表示 UNKNOWN。我们需要考虑所有从 0 出发的情况并判断坐标 0 是否是好坐标。由于坐标 1 是 GOOD，我们可以从 0 跳到 1 并且 1 最终可以跳到坐标 6，所以尽管 nums[0] 可以直接跳到最后的位置，我们只需要一种方案就可以知道结果。

Index 0 1 2 3 4 5 6
nums 9 4 2 1 0 2 0
memo U G B B B G G

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

复杂度分析

时间复杂度：O(n)，只需要访问 nums 数组一遍，共 n 个位置，n 是 nums 数组的长度。
空间复杂度：O(1)，不需要额外的空间开销。

总结

最后一个问题是，如何在面试场景中想到这个做法。我的建议是“酌情考虑”。最好的解法当然和别的解法相比更简单也更短，但是不那么容易直接想到。

递归回溯的版本最容易想到，所以在思考更复杂解法的时候可以顺带提及一下这个解法，你的面试官实际上可能会想要看到这个解法。但如果没有，请提及可以使用动态规划的解法，并试想一下如何用记忆表来实现。如果你发现面试官希望你回答自顶向下的方法，那么就不太需要思考自底向上的版本，但我推荐在面试中提及一下自底向下的优点。

很多人会在将自顶向下的动态规划转成自底向上版本时出现困难，多做一些相关的练习可以对你有所帮助。

附录 A - 方法 1 的复杂度分析

从第一个位置跳到最后一个位置最多有 2^n 种方案，其中 n 是 nums 数组的长度。，令 T(x) 是从 x 跳到 n 可能的所有方案，显然 T(n) = 1。 $\sum_{i = x + 1}^{n} T(i)$ ，因为从 x 可能跳到之后的所有顶点 i，每个顶点又有 T(i) 种方案，注意到这是最坏情况。

$\begin{aligned} T(x) &= \sum_{i = x + 1}^{n} T(i) \\ &= T(x + 1) + \sum_{i = x + 2}^{n} T(i) \\ &= T(x + 1) + T(x + 1) \\ &= 2 \cdot T(x + 1) \end{aligned}$

现在通过归纳，假设 $T(x) = 2^{n-x}$ 并证明 $T(x-1) = 2^{n-(x-1)}$ ，

$\begin{aligned} T(x - 1) &= 2 \cdot T(x) \\ &= 2 \cdot 2^{n - x} \\ &= 2^{n - x + 1} \\ &= 2^{n - (x - 1) } \end{aligned}$

这样我们就得到从位置 1 开始， $T(1) = 2^{n - 1}$ ，最终的复杂度是 $O(2^{n - 1})$ = $O(2^n)$ 。
作者：LeetCode
链接：https://leetcode-cn.com/problems/two-sum/solution/tiao-yue-you-xi-by-leetcode/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

感想

根据45题跳跃游戏II，很容易修改得到答案：

执行用时 : 4 ms, 在Jump Game的Java提交中击败了59.35% 的用户

内存消耗 : 41.3 MB, 在Jump Game的Java提交中击败了73.83% 的用户

class Solution {
    public boolean canJump(int[] nums) {
        int step = 0;
        while (step != nums.length-1&& nums[step]!=0){
            if(nums[step]>=nums.length-step-1) {
                step=nums.length-1;
                break;
            }
            int max = -1;
            int maxj = -1;
            for(int j=step+1;j<nums[step]+step+1&&j<nums.length;j++){
                if(j+nums[j]>max){
                    max = j+nums[j];
                    maxj = j;
                }
            }
            step = maxj;
        }
        if(step == nums.length-1) return true;
        else return false;
    }
}

SquareSquareHe

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
【力扣算法】55-跳跃游戏

题目给定一个非负整数数组，你最初位于数组的第一个位置。数组中的每个元素代表你在该位置可以跳跃的最大长度。判断你是否能够到达最后一个位置。示例 1:输入: [2,3,1,1,4]输出: true解释: 从位置 0 到 1 跳 1 步, 然后跳 3 步到达最后一个位置。示例 2:输入: [3,2,1,0,4]输出: false解释: 无论怎样，你总会到达索引为 3 的位置。但该...
复制链接

扫一扫