Overview
Given your array a
and the index of your current position i
, repeat the following until you reach the last element.
Consider all candidate "jump-to elements" in a[i+1]
to a[a[i] + i]
. For each such element at index e
, calculate v
= a[e]
+ e
. If one of the elements is the last element, jump to the last element. Otherwise, jump to the element with the maximal v
.
More simply put, of the elements within reach, look for the one that will get you furthest on the next jump. We know this selection, x
, is the right one because compared to every other element y
you can jump to, the elements reachable from y
are a subset of the elements reachable from x
(except for elements from a backward jump, which are obviously bad choices).
This algorithm runs in O(n) because each element need be considered only once (elements that would be considered a second time can be skipped).
Example
Consider the array of values a
, indicies, i
, and sums of index and value 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
Start at index 0 and consider the next 4 elements. Find the one with maximal v
. That element is at index 1, so jump to 1. Now consider the next 11 elements. The goal is within reach, so jump to the goal.
Demo
See here or here with code.
与恶龙缠斗过久,自身亦成为恶龙;凝视深渊过久,深渊将回以凝视…