題目描述：
給出一個非負整數陣列，你最初定位在陣列的第一個位置。
陣列中的每個元素代表你在那個位置可以跳躍的最大長度。
判斷你是否能到達陣列的最後一個位置。

注意事項：
這個問題有兩個方法，一個是貪心和 動態規劃。
貪心方法時間複雜度為O（N）。
動態規劃方法的時間複雜度為為O（n^2）。

樣例：
A = [2,3,1,1,4]，返回 true.

A = [3,2,1,0,4]，返回 false.

思路講解：
這裡我的大概思路就是迴圈遞迴去搜索其是否存在如果存在就不在搜尋，如果不存在就一直搜尋直到搜尋結束。
下面舉個栗子：
**例子是2-3-1-1-4
1.首先看該位置的最大值，是2，然後判斷移動2步能否到達終點，如果能夠，就結束。不能夠執行2.
2.最大數字是2，然後我們可以移動步數的情況有{1，2}，然後我們對於該集合中的每一種情況都執行即跳到1，**

程式碼詳解：

class Solution {
public:
    /*
     * @param A: A list of integers
     * @return: A boolean
     */
    int result=0;//用來標識是否能夠跳到終點目標
    bool canJump(vector<int> &A) {
        // write your code here

        int index=0;
        if(A.size()==1)
        {
            return true;
        }
        findres(A,index);
        if
 
(result==1){
            return true;
        }
        return false;
    }
    void findres(vector<int>A,int index)//找尋結果的函式
    {
        if(result==1){
            return ;
        }
        if(index<A.size()-1){
            int max=A[index];
            if(max==0){
                return ;
            }
            int
 
 distance=A.size()-index-1;
            if(max>=distance)//能夠到達終點的判斷
            {
                result=1;
                return ;
            }
            for(int i=1;i<=max;i++)//對每一個步數，進行遞迴判斷
            {
                findres(A,index+i);
            }
            return ;
        }
    }
};

關於跳躍遊戲Ⅱ的解答：
題目描述：
給出一個非負整數陣列，你最初定位在陣列的第一個位置。
陣列中的每個元素代表你在那個位置可以跳躍的最大長度。　　　
你的目標是使用最少的跳躍次數到達陣列的最後一個位置。

樣例
給出陣列A = [2,3,1,1,4]，最少到達陣列最後一個位置的跳躍次數是2(從陣列下標0跳一步到陣列下標1，然後跳3步到陣列的最後一個位置，一共跳躍2次)

思路解答：
一開始我還是用跳躍一的方法結果超時。so sad！
於是我想了另一種方法，這裡我用的方法是貪心法，即每一次都是找跳的最遠的位置，這裡有一個小小的彎，就是關於這個最遠是怎麼衡量的，其是不是就是某個位置的數，不是，我們不僅要考慮位置，還要考慮該位置上的數，即該位置的跳遠距離。所以，一個位置的跳遠最遠距離就是該位置的數加上該位置。這樣才能準確的表達最遠的概念。

程式碼詳解：

class Solution {
public:
    /*
     * @param A: A list of integers
     * @return: An integer
     */
    int min=INT_MAX;
    int count=0;//統計跳躍的次數
    int jump(vector<int> &A) {
        // write your code here
        int length=A.size();
        if(length==1)
        {
            return 1;
        }
        int index=0;
        find(A,0);
        return count;


    }

    void findnum(vector<int>res,int index,int num_of_jump)//利用跳躍Ⅰ的演算法做的
    {
        int max=res[index];
        int distance=res.size()-index-1;
        if(max==0){
            return ;
        }
        if(num_of_jump>min)
        {
            return;
        }
        if(max>=distance){
            num_of_jump=num_of_jump+1;
            if(num_of_jump<min){
                min=num_of_jump;
            }
            return ;
        }
        for(int i=1;i<=max;i++)
        {
            findnum(res,index+i,num_of_jump+1);
        }
    }
    void find(vector<int>res,int index)//貪心演算法做的
    {
        int max=res[index];

        int pos=0;
        int maxlength=INT_MIN;
        if(max>=res.size()-index-1)
        {
            count++;
            return ;
        }
        for(int i=1;i<=max;i++)//找出該位置彈跳範圍內的最好的下一個位置即下一次能夠跳的最遠
        {
            if((res[index+i]+i)>maxlength){
                maxlength=res[index+i]+i;
                pos=index+i;
            }
        }
        count++;
        find(res,pos);
    }
};