[Leedcode][JAVA][第55题][跳跃游戏][贪心][动态规划]

【问题描述】

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

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

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

示例 1:

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

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

【解答思路】

1. 正向贪心

时间复杂度：O(N) 空间复杂度是O(1）

  public boolean canJump(int[] nums) {
        if (nums == null || nums.length == 0) return true;
        int maxDist = 0;
        int n = nums.length;
        for (int i = 0; i < n; i++) {
            // 到不了该位置，提前终止
            if (maxDist < i) return false;
            // 可以到达末尾位置，提前终止
            if (maxDist >= n - 1) return true;
            // 更新可以到达的最远距离
            maxDist = Math.max(maxDist, nums[i] + i); 
        }
        return false;
    }

2. 反向贪心

以[2, 3, 1, 1, 4]为例，我们的目标是到达最后一个位置。
1、因为倒数第二个位置为1，所以从倒数第二个位置可以到达最后一个位置。因此只要我们能到达倒数第二个位置就能到达最后一个位置。
2、因为倒数第三个位置为1，所以从倒数第三个位置可以到达倒数第二个位置。因此只要我们能到达倒数第三个位置就能到达倒数第二个位置从而能到达最后一个位置。
3、因为倒数第四个位置为3，所以从倒数第四个位置可以到达倒数第三个位置。因此只要我们能到达倒数第四个位置就能到达倒数第三个位置从而能到达最后一个位置。
4、因为倒数第五个位置为2，所以从倒数第五个位置可以到达倒数第四个位置。因此只要我们能到达倒数第五个位置（也就是第一个位置)就能到达倒数第三个位置从而能到达最后一个位置。
因此，可以到达最后一个位置。

• 用一个变量pos来表示需要到达的位置，并初始化为nums.length - 1表示需要到达的位置为最后一个位置。
• 从nums.length - 2向前遍历，if(nums[i] + i >= pos)表示从当前位置出发能够到达pos，到达当前位置i就可以到达pos，更新pos为i的值。
• 遍历到最后如果pos==0，也就表示从开始能够跳到末尾。

时间复杂度：O(N) 空间复杂度是O(1）

public boolean canJump(int[] nums) {
        if (nums == null || nums.length == 0) {
            return false;
        }
        //pos表示需要到达的位置
        int pos = nums.length - 1;
        for (int i = nums.length - 2; i >= 0; i--) {
            if (nums[i] + i >= pos) {
                pos = i;
            }

        }
        return pos == 0;

    }

3.动态规划

我们新建一个boolean[] dp来表示能否到达该位置。初始化dp[0]=true，此时dp为[true,false,false,false,false]。
以nums = [2, 3, 1, 1, 4]为例，
1、dp[0] = true, nums[0] = 2, 因此往后推两个位置也可到达，此时dp为[true,true,true,false,false]。
2、dp[1] = true, nums[1] = 3, 因此往后推两个位置也可到达，此时dp为[true,true,true,true,true]。
此时dp[4] = true,其实已经可以表示能到达末尾了。这种表示方法在下面的代码中用表示一
3、dp[2] = true, nums[2] = 1, 因此往后推一个位置也可到达，此时dp为[true,true,true,true,true]。
4、dp[3] = true, nums[3] = 1, 因此往后推一个位置也可到达，此时dp为[true,true,true,true,true]。
此种方式用方式二表示
时间复杂度是O(N^2)，空间复杂度是O(N）

public boolean canJump1(int[] nums) {

        if (nums == null || nums.length == 0) {
            return false;
        }
        int len = nums.length;
        boolean[] dp = new boolean[len];
        dp[0] = true;
        for (int i = 0; i < len - 1; i++) {
            if (dp[i]) {
                for (int j = i; j < len && j <= i + nums[i]; j++) {
                    dp[j] = true;

                }

            }
            if (dp[len - 1]) {
                return true;
            }

        }
        return dp[len - 1];

    }


    public boolean canJump2(int[] nums) {

        if (nums == null || nums.length == 0) {
            return false;
        }
        int len = nums.length;
        boolean[] dp = new boolean[len];
        dp[0] = true;
        for (int i = 0; i < len - 1; i++) {
            if (dp[i]) {
                for (int j = i; j < len && j <= i + nums[i]; j++) {
                    dp[j] = true;

                }
            }

        }
        return dp[len - 1];

    }

【总结】

1. 动态or贪心

-如果使用动态规划，dp[i]代表能否跳到第i个格子的话，那么dp[i]本身没有办法很好地从dp[j](j < i)中得到，因为不知道有哪些格子可以跳到该点，因此动态规划的解法可能就没有那么优了。
-如果使用贪心（贪心是每个状态只使用一次的动态规划），是因为判断一个格子是否能到达，其实只要看这个格子是否在当前的可到达的区间内即可——而维护一个区间要比维护一个dp数组简单得多，况且区间的左端必然是0，那么只需要维护右端即可了~

2.思路方向找准 块状思考 边界终止条件多样化 想好再下手

3.Missing return statement” within if / for / while

if, while 或 for 里面的return 有可能不执行，编译器将强制您添加return语句
除非使用if-else结构

if(condition){
 return;
}
else{
 return;
}

参考链接：https://leetcode-cn.com/problems/jump-game/solution/shun-zhao-tui-dao-zhao-tui-liang-chong-fang-shi-ji/