跳跃游戏： 给定一个数组，从第一个元素开始，通过跳跃到达最后一个元素。跳转长度最多可以是数组中当前位置的值。最佳结果是您以最少的跳跃次数达到目标。
什么是寻找最佳结果的算法？
一个例子：给定数组A = {2,3,1,1,4} 到达末尾的可能方式（索引列表）是
0,2,3,4（从 2 跳到索引 2，然后从 1 跳到索引 3，然后从 1 跳到索引 4）0,1,4（从 1 跳转到索引 1，然后从 3 跳转到索引 4）由于第二个解决方案只有 2 次跳跃，因此它是最佳结果。
【问题讨论】：
标签： algorithm pseudocode
给定您的数组a 和您当前位置的索引i，重复以下操作直到到达最后一个元素。
考虑a[i+1] 到a[a[i] + i] 中的所有候选“跳转到元素”。对于索引e 处的每个此类元素，计算v = a[e] + e。如果其中一个元素是最后一个元素，则跳转到最后一个元素。否则，跳转到v最大的元素。
更简单地说，在触手可及的元素中，寻找能让你在下一个跳跃中走得最远的元素。我们知道这个选择 x 是正确的，因为与您可以跳转到的所有其他元素 y 相比，可从 y 访问的元素是可从 x 访问的元素的子集（除了来自向后跳跃，这显然是不好的选择）。
这个算法在 O(n) 中运行，因为每个元素只需要考虑一次（可以跳过第二次考虑的元素）。
考虑值数组a、索引、i，以及索引和值的总和v。
i -> 0 1 2 3 4 5 6 7 8 9 10 11 12
a -> [4, 11, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
v -> 4 12 3 4 5 6 7 8 9 10 11 12 13
从索引 0 开始并考虑接下来的 4 个元素。找到最大v 的那个。该元素位于索引 1 处，因此跳转到 1。现在考虑接下来的 11 个元素。目标触手可及，所以跳到目标。
【讨论】：
动态编程。
假设您有一个数组B，其中B[i] 显示到达数组A 中的索引i 所需的最小步数。你的答案当然是在B[n]，因为A 有n 元素和索引从1 开始。假设C[i]=j 表示你从索引j 跳到索引i（这是为了恢复稍后采取的路径）
所以，算法如下：
set B[i] to infinity for all i
B[1] = 0; <-- zero steps to reach B[1]
for i = 1 to n-1 <-- Each step updates possible jumps from A[i]
for j = 1 to A[i] <-- Possible jump sizes are 1, 2, ..., A[i]
if i+j > n <-- Array boundary check
break
if B[i+j] > B[i]+1 <-- If this path to B[i+j] was shorter than previous
B[i+j] = B[i]+1 <-- Keep the shortest path value
C[i+j] = i <-- Keep the path itself
需要的跳转次数是B[n]。需要走的路是：
1 -> C[1] -> C[C[1]] -> C[C[C[1]]] -> ... -> n
这可以通过一个简单的循环来恢复。
该算法的时间复杂度为O(min(k,n)*n)，空间复杂度为O(n)。 n 是 A 中的元素个数，k 是数组中的最大值。
我保留了这个答案，但是cheheen 的贪心算法是正确且更有效的。
【讨论】：
if B[i+j] > B[i]+1 不需要有>=，因为如果新路径与旧路径一样好，那么更新它就没有意义了。你不会获得任何更好的路径，而只是另一条同样好的路径。事实上，使用>= 仍然可以，但它会产生与上述算法相同的最小跳转次数的不同路径。
从数组构造一个有向图。例如： i->j if |i-j|j 作为图中的边）。现在，找到从第一个节点到最后一个节点的最短路径。
FWIW，您可以使用 Dijkstra 算法找到最短路径。复杂度为 O( | E | + | V | log | V | )。自从 | E |
【讨论】：
我们可以计算远索引跳跃最大值，如果任何一个索引值大于远，我们将更新远索引值。
简单的 O(n) 时间复杂度解决方案
public boolean canJump(int[] nums) {
int far = 0;
for(int i = 0; i<nums.length; i++){
if(i <= far){
far = Math.max(far, i+nums[i]);
}
else{
return false;
}
}
return true;
}
【讨论】：
从左（尾）开始..遍历直到数字与索引相同，使用这些数字的最大值。例如，如果列表是
list: 2738|4|6927
index: 0123|4|5678
一旦你从这个数字开始重复上述步骤，直到你到达极右。
273846927
000001234
如果您没有找到与索引匹配的内容，请使用索引最远且值大于索引的数字。在这种情况下为 7.（因为很快索引将大于数字，您可能只计算 9 个索引）
【讨论】：
基本思路：
通过查找所有数组元素开始构建从结尾到开头的路径，从这些元素中可以最后一次跳转到目标元素（所有i，例如A[i] >= target - i）。
将每个这样的i 视为新目标并找到通往它的路径（递归）。
选择找到的最小长度路径，附加target，返回。
python中的简单示例：
ls1 = [2,3,1,1,4]
ls2 = [4,11,1,1,1,1,1,1,1,1,1,1,1]
# finds the shortest path in ls to the target index tgti
def find_path(ls,tgti):
# if the target is the first element in the array, return it's index.
if tgti<= 0:
return [0]
# for each 0 <= i < tgti, if it it possible to reach
# tgti from i (ls[i] <= >= tgti-i) then find the path to i
sub_paths = [find_path(ls,i) for i in range(tgti-1,-1,-1) if ls[i] >= tgti-i]
# find the minimum length path in sub_paths
min_res = sub_paths[0]
for p in sub_paths:
if len(p) < len(min_res):
min_res = p
# add current target to the chosen path
min_res.append(tgti)
return min_res
print find_path(ls1,len(ls1)-1)
print find_path(ls2,len(ls2)-1)
>>>[0, 1, 4]
>>>[0, 1, 12]
【讨论】：