## 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.

### Analysis:

Note that the A[i] means the maximum jump length. In other words, it is possible that we move j step (<A[i]) when we at A[i], e.g. if A[i]=2, we can move either 1 or 2 steps.

The simple but time-consuming way is O(n^2). Set every future step true according to the A[i]. But this only can pass the small test.

A better idea is use another variable to save the number of steps available. Just a little bit different from the O(n^2) one , see code for more details.

Source code: (C++ : Small)

class Solution {
public:
bool canJump(int A[], int n) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
if (n==0) {return false;}
if (n==1) {return true;}

vector<bool>B(n-1,false);
B[0]=true;
for (int i=0;i<n;i++){
if (B[i]==true){
for (int j=1;j<=A[i];j++){
B[i+j]=true;
}
}
}
return B[n-1];
}
};


### Source code: (C++ : DP)

class Solution {
public:
bool canJump(int A[], int n) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
if (n==0) {return false;}
if (n==1) {return true;}

int m=0;
for (int i=0;i<n;i++){
if (i<=m){
m=max(m,A[i]+i);
if (m>=n-1){return true;}
}
}
return false;
}
};


### Code (Python):

class Solution:
# @param A, a list of integers
# @return a boolean
def canJump(self, A):
m = 0
for i in xrange(0,len(A)):
if i<=m:
m = max(A[i]+i,m)
if m>=len(A)-1:
return True
return False



1. Great post! but i+j could be out of range in your first approach. One small modification would make your 1st approach pass the large set.
public static boolean canJump1(int[] A) {
// Start typing your Java solution below
// DO NOT write main() function
int len=A.length;
if(len==0) return false;
if(len==1) return true;
boolean[] dp=new boolean[A.length];
dp[0]=true;
for(int i=0;i<len;i++){
if(dp[i]){
int c=A[i];
for(int j=1;j<=c;j++){
if(i+j<len){
dp[i+j]=true;
}else{
return true;
}
}
}
}
return dp[len-1];

}

1. Oh yes! Your code is right!

I forgot to consider the bound range.

2. class Solution {
public:
bool canJump(int A[], int n) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
if (n==0) {return false;}
if (n==1) {return true;}

int m=0;
for (int i=0;i=n-1){return true;}
}
}
return false;
}
};

why you need
vectorB(n-1,false);
B[0]=true;

in second solution?

class Solution {
public:
bool canJump(int A[], int n) {
if(!n) return false;
int target = n-1;
for(int i = n-2;i>=0;i--){
if((target-i)<=A[i]){target = i;}
}
if(target > 0) return false;
return true;
}
};

will it pass all scenarios?