【Leetcode】Jump Game 1,2

【题目】

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.

Your goal is to reach the last index in the minimum number of jumps.

For example:
Given array A = [2,3,1,1,4]

The minimum number of jumps to reach the last index is 2. (Jump 1 step from index 0 to 1, then 3 steps to the last index.)

【思路】

贪心算法

【代码】

public int jump(int[] A) {
int step_count = 0;
int last_jump_max = 0;
int current_jump_max = 0;
for(int i=0; i<A.length-1; i++) {
    current_jump_max = Math.max(current_jump_max, i+A[i]);
    if( i == last_jump_max ) {
        step_count++;
        last_jump_max = current_jump_max;
    } 
}
return step_count;

}

BFS方法

I try to change this problem to a BFS problem, where nodes in level i are all the nodes that can be reached in i-1th jump. for example. 2 3 1 1 4 , is 2|| 3 1|| 1 4 ||

clearly, the minimum jump of 4 is 2 since 4 is in level 3. my ac code.

 int jump(int A[], int n) {
	     if(n<2)return 0;
	     int level=0,currentMax=0,i=0,nextMax=0;

	     while(currentMax-i+1>0){       //nodes count of current level>0
	         level++;
	         for(;i<=currentMax;i++){   //traverse current level , and update the max reach of next level
	            nextMax=max(nextMax,A[i]+i);
	            if(nextMax>=n-1)return level;   // if last element is in level+1,  then the min jump=level 
	         }
	         currentMax=nextMax;
	     }
	     return 0;
	 }

【题目 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.

【思路】

【代码】

 public boolean canJump(int[] A) {
    int len=A.length;
    int ability=A[0];//the farmost grid index that can be reached
    for(int i=1;i<len;i++)
    {
        if(ability<i)//cannot reach beyond current grid by any means, return false
        return false;
        //update ability using the bigger grid index that can be reached
        ability=ability>i+A[i]?ability:i+A[i];
    }
    //loop finished, the last grid can be reached
    return true;
}