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.

解法1，递归超时。

递归可以构思出简单的结构，以第一个元素来举例，若该元素能跳的最大步数maxJumps>=n-dep-1(dep=0)，则说明可以到达末尾，直接return

若maxJumps<n-0-1，则我们可以跳的步数的范围为：maxJums~1，此时若我们先跳maxJums步，跳了之后，还是做同样的比较，即和n-dep-1比较，所以随着问题的深入，

每一次要解决的问题和上一次一样，只不过数组A的范围变小，所以是明显的递归。

代码：

class Solution{
private:
    bool res;
    int n;
public:
    void dfs(int A[],int dep){
        if(A[dep]==0) return;
        int maxJumps=A[dep];
        if(maxJumps>=n-dep-1){res=true;return;}
        else{
            for (int i=maxJumps;i>=1&&!res;--i)
                dfs(A,dep+i);    
        }
        return;
    }
    bool canJump(int A[], int n) {
        if(A==NULL||n==0) return false;
        this->res=false;
        this->n=n;
        dfs(A,0);
        return res;
    }
};

 2.备忘录的dp（超时）

代码：

class Solution{
private:
    bool res;
    vector<bool> dp;
    int n;
public:
    void dfs(int A[],int dep){
        if(dp[dep]==false) return;
        if(A[dep]==0) {dp[dep]=false;return;}
        int maxJumps=A[dep];
        if(maxJumps>=n-dep-1){res=true;return;}
        else{
            for (int i=maxJumps;i>=1&&!res;--i)
                dfs(A,dep+i);    
        }
        dp[dep]=false;
        return;
    }
    bool canJump(int A[], int n) {
        if(A==NULL||n==0) return false;
        this->res=false;
        this->n=n;
        dp.clear();
        dp.resize(n,1);
        dfs(A,0);
        return res;
    }
};

3.贪心算法还不熟悉（参考别人）

代码：

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