Jump Game II <LeetCode>

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.

Your goal is to reach the last index in the minimum number of jumps.

For example:
Given array A = [2,3,1,1,4]

The minimum number of jumps to reach the last index is 2. (Jump 1 step from index 0 to 1, then 3 steps to the last index.

 

说明：首先该方法会超时

刚看到这道题就想到了分支限界（广度优先遍历），直接用分支限界的思想做的，结果超时了，以下是代码

int maxx;
struct node
{
    int val;
    bool k;
};
class Solution {
public:
    int jump(int A[], int n) {
        if(n==1)  return 0;
        list<int> duilie;
        vector<node> temp;
        duilie.clear();
        temp.clear();
        maxx=0;
        for(int i=0;i<n;i++)
        {
            node no;
            no.val=A[i];
            no.k=true;
            temp.push_back(no);
        }
        duilie.push_back(0);
        return doit(temp,1,duilie,n,0);
    }
    
    
  int doit(vector<node>  temp,int dep,list<int> duilie,int nn,int mm)
  {
      int m=0;
      for(int j=0;j<=mm;j++)
      {
          int n=duilie.front();
          duilie.pop_front();
          for(int i=1;i<=temp[n].val;i++)
          {
              if(i+n<=maxx) continue;
              else  maxx=i+n;
              if(n+i<nn)
              {
                 if(n+i==nn-1)
                 {
                     return dep;
                 }
                 if(temp[n+i].k)
                 {
                    duilie.push_back(n+i);
                    m++;
                    temp[n+i].k=false;
                 }
              }
              else break;
          }
      }
       return  doit(temp,dep+1,duilie,nn,m);
  }
};

 

 

2：第二种思路是反过来想，要达到最后一条，倒数第二条至少应该到哪个位置，以此类推直到我们倒推到第一位时便可知最小跳数；

class Solution {
public:
    int jump(int A[], int n) {
        // Start typing your C/C++ solution below
        // DO NOT write int main() function
        int pre = 0;
        int cur = n - 1;
        int count = 0;
        while(true)
        {
            if(pre == cur)
            {
                return 0;
            }
            count++;
            pre = cur;
            for(int i = n - 2; i >= 0; i--)
            {
                if(i + A[i] >= pre)
                {
                    if(cur > i)
                    {
                        cur = i;
                    }
                }
            }
            if(cur == 0)
            {
                return count;
            }
        };
        
   
    }
};

3：第三种思路是用动态规划DP的观点来实现。DP[i]代表到达i的最小跳数，显然DP是一个递增的数组。每次循环只需要尽量找到最小的DP[k]，使其满足k+A[k]>=n。

class Solution {
public:
    int* dp;
    int jump(int A[], int n) {
        if(n==0)
        {
            return INT_MAX;
        }
        dp = new int[n];
        dp[0] = 0;
        for(int i=1;i<n;i++)
        {
            dp[i] = INT_MAX;
        }
        for(int i=1;i<n;i++)
        {
            for(int j=0;j<i;j++)
            {
                if(j+A[j]>=i)
                {
                    int tmp = dp[j]+1;
                    if(tmp < dp[i])
                    {
                        dp[i] = tmp;
                        break;
                    }
                }
            }
        }
        
        return dp[n-1];
    }
};