1345. Jump Game IV
Tags: algorithms, 100daysofcode, java, programming
Published: 2022-01-15 12:50:01

# Description

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`

---

# Solutions

## Solution 1

### Intuition

BFS

Put the indexes that can be reached in each step into the queue.

100,-23,-23,404,100,23,23,23,3,404
0, 1, 2, 3, 4, 5, 6, 7, 8, 9

- 0 step: 0
- 1 step: 1, 4
- 2 step: 2, 3, 5
- 3 step: 9(over)

### Code

```java
class Solution {
    public int minJumps(int[] arr) {
        int n = arr.length;
        if (n == 1) {
            return 0;
        }
        // number with indexes
        Map<Integer, List<Integer>> map = new HashMap<>();

        for (int i = 0; i < n; i++) {
            List<Integer> list = map.getOrDefault(arr[i], new ArrayList<>());
            list.add(i);
            map.put(arr[i], list);
        }

        // bfs
        Queue<Integer> queue = new LinkedList<>();
        // start at index 0
        queue.offer(0);
        // init steps with 0
        int steps = 0;
        while (!queue.isEmpty()) {
            steps++;
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                
                int index = queue.poll();
                int number = arr[index];

                // left index
                if (index - 1 >= 0 && map.containsKey(arr[index - 1])) {
                    queue.offer(index - 1);
                }
                // right index
                if (index + 1 <= n - 1 && map.containsKey(arr[index + 1])) {
                    if (index + 1 == n - 1) {
                        return steps;
                    }
                    queue.offer(index + 1);
                }
                // other indexes with same number
                if (map.containsKey(number)) {
                    for (int sameNumberIndex : map.get(number)) {
                        if (sameNumberIndex != index) {
                            if (sameNumberIndex == n - 1) {
                                return steps;
                            }
                            queue.offer(sameNumberIndex);
                        }
                    }
                }
                map.remove(number);
            }

        }
        return steps;

    }
}
```

### Complexity

- Time: O(n)
- Space: O(n)