lintcode--跳跃游戏--跳跃游戏Ⅱ

题目描述：
给出一个非负整数数组，你最初定位在数组的第一个位置。
数组中的每个元素代表你在那个位置可以跳跃的最大长度。
判断你是否能到达数组的最后一个位置。

注意事项：
这个问题有两个方法，一个是贪心和 动态规划。
贪心方法时间复杂度为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);
    }
};