首页 > 其他分享> 文章详细

Leetcode 55. Jump Game

2019-06-22 15:51:46 阅读：171 来源： 互联网

标签：index int nums 55 length Jump start Game Index

Given an array of non-negative integers, you are initially positioned at the first index of the array.

Each element in the array represents your maximum jump length at that position.

Determine if you are able to reach the last index.

Example 1:

Input: [2,3,1,1,4]
Output: true
Explanation: Jump 1 step from index 0 to 1, then 3 steps to the last index.

Example 2:

Input: [3,2,1,0,4]
Output: false
Explanation: You will always arrive at index 3 no matter what. Its maximum
jump length is 0, which makes it impossible to reach the last index.

tag: array,greedy, dynamic programming

method 1 backtracking

回溯遍历，每跳到一个位置i，就遍历i~i+nums[i]这些位置之中是否能过跳到终点，如果有一个能达到终点，就返回true

但这个方法超时了

private boolean canJump(int[] nums, int start, int max) {
        if (nums[start] == 0 && start != nums.length-1)
            return false;
        if (start + max >= nums.length-1)
            return true;

        for (int i = max; i >= 1; i--) {
           if (canJump(nums,start+i,nums[start+i]))
                return true;
        }

        return false;
    }

method 2

自顶向下动态规划，从method 1中我们可以看出，有些位置会重复遍历，因此我们引入记忆化搜索，还会回溯，但每到一个位置i时，先查看该位置是否是能够到达终点的位置(GOOD), 还是不能到达终点的位置(BAD),如果是不知道的位置(UNKNOWN)，则遍历这个位置

通过使用dp降低了复杂度，存储了index i是否能到达终点的结果，当再经过这些index的时候不再需要计算

enum Index {
        GOOD, BAD, UNKNOWN
}

Index[] index;

private boolean canJump2(int[] nums, int start) {
    start = Math.min(start,nums.length-1);

    if (index[start] != Index.UNKNOWN)
        return (index[start] == Index.GOOD)?true:false;

    int max = nums[start];
    for (int i = max; i >= 1; i--) {
        if (canJump2(nums,start+i)){
            index[start] = Index.GOOD ;
            return true;
        }
    }

    index[start] = Index.BAD;
    return false;
}

method 3

自底向上，从右边开始跳，递归转循环.先将每一个Index置为UNKNOWN，再把最后一个INDEX置为GOOD

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;
    }

method 4 Greedy

从method 3 中再次得到启发，如果在位置i，且i~nums[i]+i这之中有一个GOOD INDEX，那么代表位置i也是个GOOD INDEX

遍历完如果lastPos = 0 则表示起点也是good Index，那么从起点也可以跳到终点

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;
    }

summary：

（当方法超时的时候）发现是不是有些步骤被重复计算，如果有重复计算，那么就引入动态规划
反向思考，问的是从起点到终点，如果能从终点到起点，结果也是等价的
使用greedy 简化动态规划，进一步看清问题的本质

标签：index,int,nums,55,length,Jump,start,Game,Index
来源： https://blog.csdn.net/qq_38702697/article/details/93330676

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

Leetcode 55. Jump Game