跳跃游戏（数组、贪心）_给你一个非负整数数组 nums ,你最初位于数组的 第一个下标 。数组中的每个元素代

题目

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

示例 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 * 10^4
  0 <= nums[i] <= 105

选项

选项A

class Solution {
    public boolean canJump(int[] nums) {
        boolean can = true;
        if (nums.length < 2) {
            return can;
        }
        int n = nums.length;
        int stride = 1;
        for (int i = n - 2; i >= 0; i--) {
            if (nums[i] < stride) {
                stride++;
                can = false;
            } else {
                can = true;
                stride = 1;
            }
        }
        return can;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

选项B

class Solution {
    public boolean canJump(int[] nums) {
        boolean can = true;
        if (nums.length >= 2) {
            return can;
        }
        int n = nums.length;
        int stride = 1;
        for (int i = n - 2; i >= 0; i--) {
            if (nums[i] < stride) {
                stride++;
                can = false;
            } else {
                can = true;
                stride = 1;
            }
        }
        return can;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

选项C

class Solution {
    public boolean canJump(int[] nums) {
        boolean can = true;
        if (nums.length <= 2) {
            return can;
        }
        int n = nums.length;
        int stride = 1;
        for (int i = n - 2; i >= 0; i--) {
            if (nums[i] < stride) {
                stride++;
                can = false;
            } else {
                can = true;
                stride = 1;
            }
        }
        return can;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

选项D

class Solution {
    public boolean canJump(int[] nums) {
        boolean can = true;
        if (nums.length == 2) {
            return can;
        }
        int n = nums.length;
        int stride = 1;
        for (int i = n - 2; i >= 0; i++) {
            if (nums[i] < stride) {
                stride++;
                can = false;
            } else {
                can = true;
                stride = 1;
            }
        }
        return can;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

分析

  1、简单理解题意：你处于当前nums[0]的位置，而nums[0]的值表示你这次能跳到哪里，若最后能跳到最后一个位置，返回True，反正返回False。
  2、分析选项：首先boolean can = true; 然后选项B中 if (nums.length >= 2) {return can;}，数组长度大于等于2直接返回true，明显错误。选项D中**if (nums.length == 2) {return can;}同理，选项D中if (nums.length <= 2) {return can;}**同理，所以先排除选项BCD。（突然发现好简单！！！）
注：然后我就刷新了几遍，发现除了以上说的错误，还有就是在for循环中做手脚，如下图片所示：

代码

完整代码简单写一下

import java.util.Scanner;

class Test {
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        System.out.println("输入数组长度：");
        int N=sc.nextInt();
        int[] nums = new int[N];
        for (int i=0;i<N;i++){
            System.out.println("输入位置"+i+"的最大跳跃长度：");
            nums[i]=sc.nextInt();
        }
        if(canJump(nums)){
            System.out.println("能到达最终位置");
        }
        else{
            System.out.println("不能到达最终位置");
        }
    }
    static boolean canJump(int[] nums) {
        boolean can = true;
        if (nums.length < 2) {
            return can;
        }
        int n = nums.length;
        int stride = 1;
        for (int i = n - 2; i >= 0; i--) {
            if (nums[i] < stride) {
                stride++;
                can = false;
            } else {
                can = true;
                stride = 1;
            }
        }
        return can;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38