Given an array of integers arr, you are initially positioned at the first index of the array. In one step you can jump from index i to index:
i + 1 where: i + 1 < arr.length. i - 1 where: i - 1 >= 0. j where: arr[i] == arr[j] and i != j.Return the minimum number of steps to reach the last index of the array. Notice that you can not jump outside of the array at any time.
Example 1: Input: arr = [100,-23,-23,404,100,23,23,23,3,404] Output: 3 Explanation: You need three jumps from index 0 –> 4 –> 3 –> 9. Note that index 9 is the last index of the array.
Example 2: Input: arr = [7] Output: 0 Explanation: Start index is the last index. You do not need to jump.
Example 3: Input: arr = [7,6,9,6,9,6,9,7] Output: 1 Explanation: You can jump directly from index 0 to index 7 which is last index of the array.
Constraints:
1 <= arr.length <= 5 * 104
-108 <= arr[i] <= 108
- code
class Solution:
def minJumps(self, arr: List[int]) -> int:
n = len(arr)
d = defaultdict(list) # same value, index list
for i, v in enumerate(arr):
d[v].append(i)
q = deque([0])
visited = {0}
step = 0
while q:
for _ in range(len(q)):
cur = q.popleft()
if cur == n - 1: return step
# jumping to the same value
for nex in d[arr[cur]]:
if nex not in visited:
q.append(nex)
visited.add(nex)
d[arr[cur]].clear() # important, to prevent going back to the same value agin
# jumping to next
for nex in (cur - 1, cur + 1):
if 0 <= nex < n and nex not in visited:
q.append(nex)
visited.add(nex)
step += 1
return step
- code #bidirectionalBfs
class Solution:
def minJumps(self, arr) -> int:
n = len(arr)
if n <= 1:
return 0
graph = {}
for i in range(n):
if arr[i] in graph:
graph[arr[i]].append(i)
else:
graph[arr[i]] = [i]
curs = set([0]) # store layers from start
visited = {0, n-1}
step = 0
other = set([n-1]) # store layers from end
# when current layer exists
while curs:
# search from the side with fewer nodes
if len(curs) > len(other):
curs, other = other, curs
nex = set()
# iterate the layer
for node in curs:
# if node in other:return node Wrong! can't check here as both side already in one visited
# check same value
for child in graph[arr[node]]:
if child in other:
return step + 1
if child not in visited:
visited.add(child)
nex.add(child)
# clear the list to prevent redundant search
graph[arr[node]].clear()
# check neighbors
for child in [node-1, node+1]:
if child in other:
return step + 1
if 0 <= child < len(arr) and child not in visited:
visited.add(child)
nex.add(child)
curs = nex
step += 1
return -1
why dp doesn’t work iamninja November 17, 2020 10:19 PM Yeah, this problem disguises itself as a DP problem. Once you realize that you can arrive to the same stop (index) multiple times from duplicates, this breaks the idea of using DP. You’ll end up having to track multiple paths from that stop and considering the minimum. In most cases this is a scenario when you opt-in for BFS over DFS. Due to duplicates relation problem becomes a graph with cycles and you needs to find a shortest path.