Jump Game

leetcode OJ:https://oj.leetcode.com/

昨天晚上到今天早上A的Jump Game Medium。开始有很多情况没有考虑，后面根据错误慢慢改

思路注释中有说明

Jump Game

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.

For example:
A = [2,3,1,1,4], return true.

A = [3,2,1,0,4], return false

//如果没有0是肯定可以到达last位置的
//记录0的个数count_zero
//记录0的位置array_index_zero[]
//从0最左边位置i开始向开始位置查找  并记录到0的距离step
//如果有A[i] > step说明可以到达0右边的第一个数字
//跳出循环，验证下一个0
//如果每个0都可以跳到0右边的第一个数
//说明是可以到达last位置的

//注意考虑A中只有1个元素
//A中如果有连续出现的0

public class Solution {
    public boolean canJump(int[] A) {
        int count_zero = 0;//记录数组中0的个数
        int array_index_zero[];//这里不知道0的个数，所以没有new
        
        //1个元素直接返回true
        if(1 == A.length)
            return true;
        
        //记录0的个数
        for(int i = 0; i < A.length; i++){
            if(0 == A[i]){
                count_zero ++;
            }
        }
        if(0 == count_zero)
            return true;//全是正数,可以到达last位置,返回true
        //记录0的在数组A中的位置
        array_index_zero = new int[count_zero];//不知道zero拼对没有
        int temp = 0;
        for(int i = 0; i < A.length; i++){
            if(0 == A[i]){
                array_index_zero[temp] = i;
                temp ++;
            }
        }
        boolean isCan = false;//默认不能到达last位置
        //验证所有的0是否都能到达0右边第一个数字
        for(int i = 0; i <= count_zero - 1; i++){
            //开始验证每个0

            while(!validZero(A, array_index_zero[i])){//有个元素不行，说明就不能到达last位置
                //isCan = false;
                return false;
            }            
        }
        return true;
    }
    //验证index位置的0是否可以到达0右边第一个元素
    //3,0,0,0这个确实有点烦来着
    public boolean validZero(int A[], int index){
        boolean isValid = false;//默认不能到达
        int steps = 1;//距离index的距离
        //如果0是最后一个元素，返回true
        if(A.length - 1 == index)
            return true;
        //找出左边连续出现的0
        while(index > 0 && 0 == A[--index])
            steps++;
        
        //index++;
        for(int i = index; i >= 0 && 0 != A[i]; i--){
            if(A[i] > steps){
                isValid = true;
                break;//只要有一个大于这个距离就可以跳出
            }
            steps++;
        }
        
        return isValid;
    }
}

 PS:别人的贪心算法

public class Solution {
    public boolean canJump(int[] A) {
        if(0 == A.length || 1 == A.length)
            return true;
        int maxcan = 0;
        
        for(int i = 0; i < A.length; i++){
            if(maxcan >= A.length - 1)
                return true;
            maxcan = Math.max(maxcan, A[i] + i);
            if(maxcan == i){
                return false;
            }
        }
        return true;
    }
}

找出每一次的最大距离，如果可以到last位置,返回true。

只有当第i次时maxcan == i即第i的位置为0而前面所有位置不可能跳过这个0返回false

这里贪心算法还不是很了解，还需要多熟悉一下