题目描述

原题链接

给定一个非负整数数组 nums ，你最初位于数组的 第一个下标 。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个下标。

示例 1：
输入：nums = [2,3,1,1,4]
输出：true
解释：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。

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

提示：

  • 1 <= nums.length <= 3 * 104
  • 0 <= nums[i] <= 105

个人解法

Javascript

Java

  1. class Solution {
  2.     public boolean canJump(int[] nums) {
  3.         int l= nums.length,now=l-1;
  4.         for (int i=l-2;i>=0;i--){
  5.             if (nums[i]>=now-i){
  6.                 now=i;
  7.             }
  8.         }
  9.         if (now==0){
  10.             return true;
  11.         }else {
  12.             return false;
  13.         }
  14.     }
  15. }

其他解法

Java

贪心算法

  1. class Solution {
  2.     public boolean canJump(int[] nums) {
  3.         int l= nums.length,sum=0;
  4.         for (int i=0;i<l;i++){
  5.             if (sum>=i){
  6.                 sum=Math.max(sum,i+nums[i]);
  7.                 if (sum>=l-1){
  8.                     return true;
  9.                 }
  10.             }
  11.         }
  12.         return false;
  13.     }
  14. }

动态规划

  1. class Solution {
  2.     public boolean canJump(int[] nums) {
  3.         int l = nums.length, sum = 0;
  4.         boolean[] dp = new boolean[l];
  5.         dp[0] = true;
  6.         for (int i = 1; i < l; i++) {
  7.             for (int j = 0; j < l; j++) {
  8.                 if (dp[j] && nums[j]+j >= i) {
  9.                     dp[i] = true;
  10.                     break;
  11.                 }
  12.             }
  13.         }
  14.         return dp[l - 1];
  15.     }
  16. }

Javascript

方法1.动态规划

思路：dp[i]表示能否到达位置i，对每个位置i判断能否通过前面的位置跳跃过来，当前位置j能达到，并且当前位置j加上能到达的位置如果超过了i，那dp[i]更新为ture，便是i位置也可以到达。
复杂度：时间复杂度O(n^2)，空间复杂度O(n)

  1. function canJump(nums) {
  2.     let dp = new Array(nums.length).fill(false); //初始化dp
  3.     dp[0] = true; //第一项能到达
  4.     for (let i = 1; i < nums.length; i++) {
  5.         for (let j = 0; j < i; j++) {
  6.             //当前位置j能达到，并且当前位置j加上能到达的位置如果超过了i，那dp[i]更新为ture，便是i位置也可以到达
  7.             if (dp[j] && nums[j] + j >= i) {
  8.                 dp[i] = true;
  9.                 break;
  10.             }
  11.         }
  12.     }
  14.     return dp[nums.length - 1];
  15. }

方法2.贪心

image.png
思路：不用考虑每一步跳跃到那个位置，而是尽可能的跳跃到最远的位置，看最多能覆盖的位置，不断更新能覆盖的距离。
复杂度：时间复杂度O(n)，遍历一边。空间复杂度O(1)

  1. var canJump = function (nums) {
  2.     if (nums.length === 1) return true; //长度为1 直接就是终点
  3.     let cover = nums[0]; //能覆盖的最远距离
  4.     for (let i = 0; i <= cover; i++) {
  5.         cover = Math.max(cover, i + nums[i]); //当前覆盖距离cover和当前位置加能跳跃的距离中取一个较大者
  6.         if (cover >= nums.length - 1) {
  7.             //覆盖距离超过或等于nums.length - 1 说明能到达终点
  8.             return true;
  9.         }
  10.     }
  11.     return false; //循环完成之后 还没返回true 就是不能达到终点
  12. };