Problem link: Minimum jumps to reach end via prime teleportation

My solution:

class Solution {
    public int minJumps(int[] nums) {
        int maxVal = 1000_000;
        int[] spf = new int[maxVal + 1];
        for (int i = 2; i <= maxVal; i++) {
            if (spf[i] == 0) {
                spf[i] = i;
                for (long j = (long) i * i; j <= maxVal; j += i) {
                    if (spf[(int) j] == 0) {
                        spf[(int) j] = i;
                    }
                }
            }
        }
        int n = nums.length;
        HashMap<Integer, ArrayList<Integer>> hm = new HashMap<>();
        for (int i = 0; i < n; i++) {
            int temp = nums[i];
            while (temp > 1) {
                int p = spf[temp];
                if (!hm.containsKey(p))
                    hm.put(p, new ArrayList<>());
                hm.get(p).add(i);
                while (temp % p == 0)
                    temp /= p;
            }
        }
        Queue<Integer> q = new LinkedList<>();
        boolean[] visitedPrime = new boolean[maxVal + 1];
        int[] dist = new int[n];
        Arrays.fill(dist, -1);
        dist[0] = 0;

        q.add(0);

        while (!q.isEmpty()) {
            int u = q.poll(), c = dist[u];

            if (u == n - 1)
                return c;

            if (u - 1 >= 0 && dist[u - 1] == -1) {
                dist[u - 1] = c + 1;
                q.add(u - 1);
            }
            if (u + 1 < n && dist[u + 1] == -1) {
                dist[u + 1] = c + 1;
                q.add(u + 1);
            }

            if (spf[nums[u]] == nums[u] && !visitedPrime[nums[u]]) {
                visitedPrime[nums[u]] = true;
                for (int idx : hm.getOrDefault(nums[u], new ArrayList<>()))
                    if (idx != u && dist[idx] == -1) {
                        dist[idx] = c + 1;
                        q.add(idx);
                    }
            }
        }

        return -1;
    }
}