跳跃游戏

跳跃游戏

题目

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

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

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

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

示例 2:

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

思路

方法1 用栈进行处理

一开始看到这个题目一看就是一个递归问题，每次判断当前位置加上可以跳的步数是否到达终点，如果不是往前回溯。
使用非递归的模式进行求解，利用stack的结构，每次存储可以跳跃的每个位置信息

public boolean canJump(int[] nums) {
        //1、构建一个stack，每次把可以跳的步数的位置加载进来
        //2、每次提取stack的栈顶元素，如果有可以跳的，进行增加，否则退出提取下一个元素
        //3、当到达终点，游戏结束返回true，否则当栈为空返回false
        if(nums.length == 0 || (nums[0] == 0 && nums.length > 1)) return false;
        Stack<Integer> numStack = new Stack<Integer>();
        numStack.add(0);
        int index;
        boolean flag = false;

        while(!numStack.isEmpty()){
            index = numStack.pop();
            int tmp = nums[index];
            while(tmp>0){
                index ++;
                tmp--;
                if(index<nums.length && nums[index]==0)continue;
                numStack.add(index);//记录下标
            }
            if(index+1 >= nums.length){
                flag = true;
                break;
            }
        }
        return flag;
    }

提交一下，很明显超时了，其实很多位置已经考虑过了，没必要在重新加入栈中，所以应该有记忆的功能，把已经到达过的位置，置零。

public boolean canJump(int[] nums) {
        //1、构建一个stack，每次把可以跳的步数的位置加载进来
        //2、每次提取stack的栈顶元素，如果有可以跳的，进行增加，否则退出提取下一个元素
        //3、当到达终点，游戏结束返回true，否则当栈为空返回false
        if(nums.length == 0 || (nums[0] == 0 && nums.length > 1)) return false;
        Stack<Integer> numStack = new Stack<Integer>();
        numStack.add(0);
        int index;
        boolean flag = false;

        while(!numStack.isEmpty()){
            index = numStack.pop();
            int tmp = nums[index];
            nums[index]=0;
            while(tmp>0){
                index ++;
                tmp--;
                if(index<nums.length && nums[index]==0)continue;
                numStack.add(index);//记录下标
            }
            if(index+1 >= nums.length){
                flag = true;
                break;
            }
        }
        return flag;
    }

方法2：更简单的思路

每个时刻记录截止到这个时刻最长可以跳的长度sum，判断当前位置是否可以到达，sum=0的时候，当前位置不可达如果不可到达，返回false，可以到达，计算截止到当前位置原先可以调的最大长度，和当前位置可跳长度取最大值，代表当前位置可以跳到最远的距离，做一次遍历即可。边界注意，nums[0] 处于当前位置也算可以到达，返回true

    public boolean canJump(int[] nums) {
        if(nums == null) return false;
        int sum = nums[0];//可跳的长度
        int len = nums.length;
        if(len < 2) return true;
        for(int i = 0; i < len ; i++){
            if(sum <= 0) return false;
            sum = Math.max(sum-1, nums[i]);
        }
        return true;

    }

小结

这道题本身不难，不够要记住边界等位置的判断，例如输入[0]应该是返回true的，开始就是终点，能够到达。