技術標籤：Java

問題：

難度：hard

說明：

題目給出一個數組，從陣列頭開始，到陣列末，返回最小需要多少步。

每一步只能操作：

1、往前一步 i + 1 < arr.length;

2、往後一步 i - 0 >= 0

3、跳到 arr[i] == arr[j] 的另外一個 j 位置

題目連線：https://leetcode.com/problems/jump-game-iv/

相關演算法：

[Leetcode學習-java]Jump Game I~III：

https://blog.csdn.net/qq_28033719/article/details/110378502

輸入範圍：

• 1 <= arr.length <= 5 * 10^4
• -10^8 <= arr[i] <= 10^8

輸入案例：

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 don't 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.

Example 4:
Input: arr = [6,1,9]
Output: 2

Example 5:
Input: arr = [11,22,7,7,7,7,7,7,7,22,13]
Output: 3
 
 

我的程式碼：

其實這題達不到 hrad 難度，就用 bfs 就可以了，但我就是想不出來，想了個 全排列， dfs 然後居然想到了 dp 然後就自亂腳步了。

講道理，JumpGame II 才是有深度的題，但是 II 只不過是 medium

Jump Game II ：https://blog.csdn.net/qq_28033719/article/details/110378502

只需要用 bfs，把下一步所有可能的點都放入佇列中，而且不能夠是已經訪問的點，此外上一步已經訪問的點也不會在下一步存在，因為 bfs 就是有特點，同一階的節點不會訪問另一個節點，而且按照走的步數，也確實，當前所有可能的步數狀態集不應該存在於下一個狀態集。

class Solution {
    public int minJumps(int[] arr) {
        int len = arr.length, begin = 0, end = 1, count = 0;
        Map<Integer, List<Integer>> cache = new HashMap<>();
        for(int i = 0; i < len; i ++) {
            cache.putIfAbsent(arr[i], new ArrayList<Integer>());
            cache.get(arr[i]).add(i);
        }
        int[] queue = new int[len]; // 用佇列 bfs
        boolean visited[] = new boolean[len]; // bfs 特徵, 一個節點不會被其他同階節點訪問
        visited[0] = true;
        while(begin < end) {
            int e = end;
            for(;begin < e;begin ++) {
                int temp = queue[begin], bTemp = temp - 1, nTemp = temp + 1;
                if(temp == len - 1) return count;
                if(cache.containsKey(arr[temp])) // 添加了節點下一階就移除
                    for(Integer index : cache.get(arr[temp])) 
                        if(!visited[index] && index != temp) {
                             queue[end ++] = index;
                            visited[index] = true;
                        }
                cache.remove(arr[temp]);
                if(bTemp > 0 && !visited[bTemp]) { // 加入 -1 節點
                    queue[end ++] = bTemp;
                    visited[bTemp] = true;
                }
                if(nTemp < len && !visited[nTemp]) { // 加入 +1 節點
                    queue[end ++] = nTemp;
                    visited[nTemp] = true;
                }
            }
            count ++;
        }
        return -1;
    } 
}