LeetCode45--Jump Game II

这一题思路其实挺明确的，有点类似跳台阶，就是怎么从第一个最快的跑到最后一个元素去，刚开始大家容易被带偏想到贪心算法，但是这一题贪心算法显示行不通，你这次跳的远，但是你到达的台阶可能并不能让你跳的很远，甚至是0直接跳不了，而你中间可能忽略了几匹黑马，他们说不定可以直接跳到终点！（如3 50 3 0 2 6）

那么换种思路？我最终是从第一个元素出发，它可以到达某些台阶，我到那些台阶都是跳一次，那么我想最快到达终点，就取决于他们那些台阶哪个可以更快到达终点了，以此类推，很容易就写出递归函数了，但是！！真的可以这么简单吗？如果给你INT_MAX个很大很大的数，那程序要找到什么时候去？？？
首先这个算法思路没有问题，so，我们来做点优化看会不会好一点，==当我们这个位置加上位置上的值大于等于末尾的下标，意味着我们可以一步跳到那里，就不用去找这其中的一个最小值了。==那么，如果一步到不了的怎么办呢？难道还是要按之前说的一个个找吗？别急，我们稍后来分析分析算法实际上做了什么，为了比较符合大家的思维，我们先看看非递归版本怎么做。
我们递归是算第一个，然后变成算它能控制的那个范围内的最小值，为了得到最小值，我们又分别去计算那些里的一个值是多少。最终变成了，最后一个元素到最后一个元素只需要0步，值为0，前一个元素若不为0，则为1。
同理。我们非递归就是反过来，还原它的这个过程，从后面往前算倒推回去，分别计算后面的每一个元素到达最后一个元素的最少步数，并用一个flag数组分别记录对应位置的最少步数就可以了。比如我们通过第k个元素的值，从它控制的那些数里找到记录里的最少步数，然后设置自己的最小步数为那个的最少步数加1，自己到那个元素，然后从它跑到终点去；然后再计算通过k-1个元素的值去找它控制的元素记录里的最小值…直到找完了，那么flag[0]就是我们要求的。
我们在这个过程中无非就是把下标不停的往左移，然后找最小值了，那能不能在这个找最小值做个优化呢？我们简单分析分析两个相邻元素之间的关系。

A和B他们的值分别是l1和l2，第一次，我们遍历了B+1到B+l2找到了最小值M，然后我们算A的，从A+1,到A+l1找到了最小值N，这个M与N有没有联系呢？

我们在纸上简单画个数轴就会发现，其实他们很有可能是一个包含的关系的。1、当A+l1正好等于B+l2的时候，那我们其实没必要循环算一次，因为他们代表的区间基本一致，只多了一个B（显然为M+1大于M），故此时最小值就是M。2、当A+l1大于B+l2的时候，A需要遍历的区间是比B要多的，但是B的那段区间我们已经找到了最小值，就无需再遍历找一遍了，所以我们只要看多出的区间里是否有比这个M更小的即可。3、当A+l1小于B+l2的时候，我暂时没有发现什么很好的结论，那就直接遍历找一遍呗，找到最小的即可。最终通过这样的分析，我们可以对这个找最小值做了大量剪枝。
好啦 Show Code

#include<cstdlib>
#include<algorithm>
class Solution {
public:
    int jump(vector<int>& nums) {
        //用数组记录从i位置到结束最少需要几步.若无法到则直接设置为length+1步
        //若数组为空，或者数组只有一个元素，则直接返回0，若只有两个元素，则返回
        int *flag;
        int len = nums.size();
        if(len == 0 || len == 1)
            return 0;
        if(len == 2)
            return 1;
        flag = (int *)malloc(sizeof(int)*len);
        flag[len-1] = 0;
        for(int i = len-2;i >= 0;--i)
        {
            //计算第i个的时候，看它能够到达哪些位置，并找到一个最小的，自己就为那个+1步
            if(nums[i] == 0)
            {
                flag[i] = len+1;
                continue;
            }
            //剪枝减少计算
            //计算i位置的最小值时，先判断自己的区间是否包括了i+1计算的区间，
            //如果包括了，且没有多余，那就等于min+1，如果包括了，且有多余，则判断多余的有效空间里是否存在更小的。
            //若没有包括，则一个个找
            if(i+nums[i] >= len-1)
            {
                flag[i] = 1;
                continue;
            }
            if(i+nums[i] == i+1+nums[i+1])
                flag[i] = flag[i+1];
            else if(i+nums[i] > i+1+nums[i+1])//比它有多
            {
                int m = flag[i+1]-1;//这是之前最快到达的，现在看有没有比它更快的
                int k = min(i+nums[i],len-2);
                    for(int j = i+2+nums[i+1];j <= k;++j)
                    if(flag[j] < m)
                        m = flag[j];
                flag[i] = m+1;
            }
            else
            {
                //比那个范围要小，那就只能死找了
                int m = min(i+nums[i],len-1);
                for(int j = m-1;j > i;--j)
                    if(flag[j] < flag[m])
                        m = j;
                flag[i] = flag[m]+1;
            }
        }
        len = flag[0];
        free(flag);
        return len;
    }
};

不做后面的剪枝在这组数据会超时：
[25000,24999,24998,24997,24996,24995,24994,24993,…,3,2,1,1,0]