leetcode jump game ii

题目：

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.)

 这一题是自己做出来的。

首先考虑动态规划的方法。定义一个数组distance[n] (n=A.length) distance[i]表示从A[0]移动到A[i]所需的最少步数。

初始化时，所有distance[i]都为postive limit。表示都不可达。

然后依次加入元素，第一轮循环从A[0]开始，表示从A[0]出发达到各个点的最小步数。

第二轮从A[1]开始，表示，从A[1]出发到达各个点的最小步数。

。。。。以此类推

则其状态转移方程为

if((j-i)<distance[i])//从i出发是否可以到达j

　if(distance[i]+1<distance[j])//这一路线是否比当前路线更优　

　　　　distance[j]=distance[i]+1

然而超时。

 

 

考虑了一下，该题的Tag中有Greedy。则开始考虑贪心的方法。

这个题目中，只要A[i]的值大于其步长，就可以跳到。因此，只要考虑这个条件即可。

不再考虑元素位置，而考虑步数。即，一步最远可以跳到哪，两步最远可以跳到哪，以此类推，直到可以跳到终点。

以两步为例

从A[0]出发最远可以到达A[i]。则当0<k<i 时,A[k]都可以一步到达

因此，当情况为2步时，可以从1-i中中任意一点为出发点，计算其最远可以到达的地方，假设为j。

当情况为3步时，只需计算从i，i+1,i+2....j出发，可以达到的最远距离。

当最远距离超过数组A的长度时，即返回步数。

下面给出代码

 

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

public class Solution {

    /**
     * @param args
     */ 
    public int jump(int[] nums) {
        int end=nums[0];
        int path=1;
        int lastPoint=0;
        int next=nums[0];
        if(nums.length==1)
            return 0;
        while(true)
        {
            if(next>=nums.length-1)
                return path;
             next=findMaxMid(nums,lastPoint,end);
            path++;
            
            lastPoint=end;
            end=next;
            
        //    System.out.println(lastPoint+"*"+end);
            
        }
        
    }
    public int findMaxMid(int []nums,int lastPoint,int end)
    {
    
        int max=-1;
        int maxIndex=-1;
        for(int i=lastPoint;i<=end;i++)
        {
            if(max<nums[i]+i)
            {
                max=nums[i]+i;
                maxIndex=i;
            }
        }
        return max;
    }
     public static void print(int []nums)
     {
         String result="{";
         for(int i:nums)
         {
             result+=i+",";
         }
         System.out.println(result+"}");
     }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int []a=new int[10000];
        for(int i=0;i<10000;i++)
        {
            a[i]=1;
        }
        int []b={2,3,1,1,4};
        int []c=new int[25002];
        for(int i=25000;i>=1;i--)
        {
            c[25000-i]=i;
        }
        c[25000]=1;
        c[25001]=0;
        //new Solution2().print(c);
        Scanner scanner=null;
        try {
             scanner=new Scanner(new File("D://data.txt"));
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        int[] d=new int[30000];
        int i=0;
        while(scanner.hasNext())
        {
            String all=scanner.next();
            for(String as:all.split(","))
            {
                d[i]=Integer.parseInt(as);
                i++;
            }
        }
        for(int j=0;j<i;j++)
        {
            c[j]=d[j];
        }
        print(c);
        
        System.out.println(new Solution().jump(c));
    }

}

 

转载于:https://www.cnblogs.com/elnino/p/5454639.html