feat: add solutions for lc No.3629 (#5189)

Author: yanglbme

solution/3600-3699/3629.Minimum Jumps to Reach End via Prime Teleportation/README.md

@@ -107,32 +107,291 @@ tags:
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：预处理 + BFS
+
+我们首先预处理出 $10^6$ 内的每个数的质因数列表，记录在 $\textit{factors}$ 中。
+
+然后我们构建一个图 $g$，对于每个下标 $i$ 和 $p \in \textit{factors}[nums[i]]$，我们将 $i$ 加入 $g[p]$ 中。这样我们就得到了每个质数 $p$ 可以传送到的下标列表。
+
+接下来我们使用广度优先搜索来求解最少跳跃次数。我们维护一个队列 $q$ 来存储当前可以跳跃到的下标，初始时 $q$ 中只有下标 $0$。每次从 $q$ 中取出一个下标 $i$，如果 $i$ 是目标下标 $n - 1$，则返回当前跳跃次数；否则，我们将 $g[nums[i]]$ 中的所有下标加入 $q$ 中，并将它们从 $g[nums[i]]$ 中移除，以避免重复访问；同时，我们还将相邻的下标 $i + 1$ 和 $i - 1$（如果在边界内）加入 $q$ 中。
+
+时间复杂度 $O(n \log M)$，空间复杂度 $O(n \log M)$，其中 $n$ 是数组的长度，而 $M$ 是数组中元素的最大值。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
-
+mx = 10**6 + 1
+factors = [[] for _ in range(mx)]
+for i in range(2, mx):
+    if not factors[i]:
+        for j in range(i, mx, i):
+            factors[j].append(i)
+
+
+class Solution:
+    def minJumps(self, nums: List[int]) -> int:
+        n = len(nums)
+        g = defaultdict(list)
+        for i, x in enumerate(nums):
+            for p in factors[x]:
+                g[p].append(i)
+        ans = 0
+        vis = [False] * n
+        vis[0] = True
+        q = [0]
+        while 1:
+            nq = []
+            for i in q:
+                if i == n - 1:
+                    return ans
+                idx = g[nums[i]]
+                idx.append(i + 1)
+                if i:
+                    idx.append(i - 1)
+                for j in idx:
+                    if not vis[j]:
+                        vis[j] = True
+                        nq.append(j)
+                idx.clear()
+            q = nq
+            ans += 1
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    private static final int mx = 1000001;
+    private static final List<Integer>[] factors = new List[mx];
+
+    static {
+        for (int i = 0; i < mx; i++) {
+            factors[i] = new ArrayList<>();
+        }
+        for (int i = 2; i < mx; i++) {
+            if (factors[i].isEmpty()) {
+                for (int j = i; j < mx; j += i) {
+                    factors[j].add(i);
+                }
+            }
+        }
+    }
+
+    public int minJumps(int[] nums) {
+        int n = nums.length;
+        Map<Integer, List<Integer>> g = new HashMap<>();
+        for (int i = 0; i < n; i++) {
+            int x = nums[i];
+            for (int p : factors[x]) {
+                g.computeIfAbsent(p, k -> new ArrayList<>()).add(i);
+            }
+        }
+        int ans = 0;
+        boolean[] vis = new boolean[n];
+        vis[0] = true;
+        Deque<Integer> q = new ArrayDeque<>();
+        q.offer(0);
+        while (true) {
+            Deque<Integer> nq = new ArrayDeque<>();
+            for (int i : q) {
+                if (i == n - 1) {
+                    return ans;
+                }
+                List<Integer> idx = g.getOrDefault(nums[i], new ArrayList<>());
+                idx.add(i + 1);
+                if (i > 0) {
+                    idx.add(i - 1);
+                }
+                for (int j : idx) {
+                    if (!vis[j]) {
+                        vis[j] = true;
+                        nq.offer(j);
+                    }
+                }
+                idx.clear();
+            }
+            q = nq;
+            ans++;
+        }
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+const int mx = 1e6 + 1;
+vector<int> factors[mx];
+
+int init = [] {
+    for (int i = 2; i < mx; ++i) {
+        if (factors[i].empty()) {
+            for (int j = i; j < mx; j += i) {
+                factors[j].push_back(i);
+            }
+        }
+    }
+    return 0;
+}();
+
+class Solution {
+public:
+    int minJumps(vector<int>& nums) {
+        int n = nums.size();
+        unordered_map<int, vector<int>> g;
+        for (int i = 0; i < n; i++) {
+            int x = nums[i];
+            for (int p : factors[x]) {
+                g[p].push_back(i);
+            }
+        }
+        int ans = 0;
+        vector<bool> vis(n, false);
+        vis[0] = true;
+        queue<int> q;
+        q.push(0);
+        while (true) {
+            queue<int> nq;
+            while (!q.empty()) {
+                int i = q.front();
+                q.pop();
+                if (i == n - 1) {
+                    return ans;
+                }
+                vector<int> idx = g[nums[i]];
+                idx.push_back(i + 1);
+                if (i > 0) {
+                    idx.push_back(i - 1);
+                }
+                for (int j : idx) {
+                    if (!vis[j]) {
+                        vis[j] = true;
+                        nq.push(j);
+                    }
+                }
+                g[nums[i]].clear();
+            }
+            q = nq;
+            ans++;
+        }
+    }
+};
 ```
 
 #### Go
 
 ```go
+const mx = 1000001
+
+var factors [mx][]int
+
+func init() {
+	for i := 2; i < mx; i++ {
+		if len(factors[i]) == 0 {
+			for j := i; j < mx; j += i {
+				factors[j] = append(factors[j], i)
+			}
+		}
+	}
+}
+
+func minJumps(nums []int) int {
+	n := len(nums)
+	g := make(map[int][]int)
+	for i, x := range nums {
+		for _, p := range factors[x] {
+			g[p] = append(g[p], i)
+		}
+	}
+	ans := 0
+	vis := make([]bool, n)
+	vis[0] = true
+	q := []int{0}
+	for {
+		nq := []int{}
+		for _, i := range q {
+			if i == n-1 {
+				return ans
+			}
+			idx := append([]int{}, g[nums[i]]...)
+			idx = append(idx, i+1)
+			if i > 0 {
+				idx = append(idx, i-1)
+			}
+			for _, j := range idx {
+				if !vis[j] {
+					vis[j] = true
+					nq = append(nq, j)
+				}
+			}
+			g[nums[i]] = []int{}
+		}
+		q = nq
+		ans++
+	}
+}
+```
 
+#### TypeScript
+
+```ts
+const mx = 1000001;
+const factors: number[][] = Array(mx);
+
+for (let i = 0; i < mx; i++) {
+    factors[i] = [];
+}
+for (let i = 2; i < mx; i++) {
+    if (factors[i].length === 0) {
+        for (let j = i; j < mx; j += i) {
+            factors[j].push(i);
+        }
+    }
+}
+
+function minJumps(nums: number[]): number {
+    const n = nums.length;
+    const g = new Map<number, number[]>();
+    for (let i = 0; i < n; i++) {
+        const x = nums[i];
+        for (const p of factors[x]) {
+            if (!g.has(p)) {
+                g.set(p, []);
+            }
+            g.get(p)!.push(i);
+        }
+    }
+    let ans = 0;
+    const vis = new Array(n).fill(false);
+    vis[0] = true;
+    let q: number[] = [0];
+    while (true) {
+        const nq: number[] = [];
+        for (const i of q) {
+            if (i === n - 1) {
+                return ans;
+            }
+            const idx = [...(g.get(nums[i]) || [])];
+            idx.push(i + 1);
+            if (i > 0) {
+                idx.push(i - 1);
+            }
+            for (const j of idx) {
+                if (!vis[j]) {
+                    vis[j] = true;
+                    nq.push(j);
+                }
+            }
+            if (g.has(nums[i])) {
+                g.get(nums[i])!.length = 0;
+            }
+        }
+        q = nq;
+        ans++;
+    }
+}
 ```
 
 <!-- tabs:end -->