跳跃游戏——一个leetcode的算法题

给定一个非负整数数组，你最初位于数组的第一个位置。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

你的目标是使用最少的跳跃次数到达数组的最后一个位置。

示例:

输入: [2,3,1,1,4]
输出: 2
解释: 跳到最后一个位置的最小跳跃数是 2。
     从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。

说明:

假设你总是可以到达数组的最后一个位置。

方法1：我们从一个点可以跳好几个点，我先想到的就是图的连接  唉仔细分析发现这就是个图搜索问题吗  最短路径问题，这里的边的权重都是1  ，广搜就好。由于这里的数字可能重复 ，所以我用name给每个数字重新命名

def jump(self, nums):
    import queue
    def BFS(graph,name):
        q=queue.Queue()
        if name[0] == name[-1]:
            return 0
        for value in graph[name[0]]:
            q.put((value,1))
        while not q.empty():
            node = q.get()
            if node[0] == name[-1]:
                return 	node[1]
            for value in graph[node[0]]:
                lists  = [p[0] for p in  list(q.queue)]
                if value not in  lists :
                    q.put((value,node[1]+1))


    length = len(nums)
    graph = {}
    name = [j for j in range(length)]
    for j in range(length):
        num = nums[j]
        graph[j] = []
        for i in range(j+1,num+j+1):
            if i<length:
                graph[j].append(name[i])
    return BFS(graph,name)

但是经过仔细思考发现这个问题的时间复杂度是o(n^2)，python代码通不过最后一个case。

方法2：利用贪心算法+动态规划来解决，思想是找到走一步最多能走多远，然后找第二步最多能走多远，第三部最多能走多远这样的思想来解决的，然后计算一下就OK了，python代码很简洁，其中第一位要做特殊处理。时间复杂度o(n)

 def jump(self, nums):
    length = len(nums)
    pre_maxsize=0
    cur_maxsize = 0
    count = 1
    if length == 1:
        return 0
    for i in range(0,len(nums)):
        cur_maxsize = max(nums[i]+i,cur_maxsize)
        if cur_maxsize >=length-1:
            return count
        if i==pre_maxsize:
            pre_maxsize = cur_maxsize
            count+=1