feat: add solutions to lc problem: No.1766

No.1766.Tree of Coprimes

Author: yanglbme

solution/1700-1799/1766.Tree of Coprimes/README.md

@@ -59,22 +59,211 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：预处理 + 枚举 + 栈 + 回溯**
+
+由于题目中 $nums[i]$ 的取值范围为 $[1, 50]$，因此我们可以预处理出每个数的所有互质数，记录在数组 $f$ 中，其中 $f[i]$ 表示 $i$ 的所有互质数。
+
+接下来我们可以使用回溯的方法，从根节点开始遍历整棵树，对于每个节点 $i$，我们可以通过 $f$ 数组得到 $nums[i]$ 的所有互质数。然后我们枚举 $nums[i]$ 的所有互质数，找到已经出现过的且深度最大的祖先节点 $t$，即为 $i$ 的最近的互质祖先节点。这里我们可以用一个长度为 $51$ 的栈数组 $stks$ 来获取每个出现过的值 $v$ 的节点以及其深度。每个栈 $stks[v]$ 的栈顶元素就是最近的深度最大的祖先节点。
+
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为节点个数。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def getCoprimes(self, nums: List[int], edges: List[List[int]]) -> List[int]:
+        def dfs(i, fa, depth):
+            t = k = -1
+            for v in f[nums[i]]:
+                stk = stks[v]
+                if stk and stk[-1][1] > k:
+                    t, k = stk[-1]
+            ans[i] = t
+            for j in g[i]:
+                if j != fa:
+                    stks[nums[i]].append((i, depth))
+                    dfs(j, i, depth + 1)
+                    stks[nums[i]].pop()
+
+        g = defaultdict(list)
+        for u, v in edges:
+            g[u].append(v)
+            g[v].append(u)
+        f = defaultdict(list)
+        for i in range(1, 51):
+            for j in range(1, 51):
+                if gcd(i, j) == 1:
+                    f[i].append(j)
+        stks = defaultdict(list)
+        ans = [-1] * len(nums)
+        dfs(0, -1, 0)
+        return ans
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    private List<Integer>[] g;
+    private List<Integer>[] f;
+    private Deque<int[]>[] stks;
+    private int[] nums;
+    private int[] ans;
+
+    public int[] getCoprimes(int[] nums, int[][] edges) {
+        int n = nums.length;
+        g = new List[n];
+        Arrays.setAll(g, k -> new ArrayList<>());
+        for (var e : edges) {
+            int u = e[0], v = e[1];
+            g[u].add(v);
+            g[v].add(u);
+        }
+        f = new List[51];
+        stks = new Deque[51];
+        Arrays.setAll(f, k -> new ArrayList<>());
+        Arrays.setAll(stks, k -> new ArrayDeque<>());
+        for (int i = 1; i < 51; ++i) {
+            for (int j = 1; j < 51; ++j) {
+                if (gcd(i, j) == 1) {
+                    f[i].add(j);
+                }
+            }
+        }
+        this.nums = nums;
+        ans = new int[n];
+        dfs(0, -1, 0);
+        return ans;
+    }
+
+    private void dfs(int i, int fa, int depth) {
+        int t = -1, k = -1;
+        for (int v : f[nums[i]]) {
+            var stk = stks[v];
+            if (!stk.isEmpty() && stk.peek()[1] > k) {
+                t = stk.peek()[0];
+                k = stk.peek()[1];
+            }
+        }
+        ans[i] = t;
+        for (int j : g[i]) {
+            if (j != fa) {
+                stks[nums[i]].push(new int[] {i, depth});
+                dfs(j, i, depth + 1);
+                stks[nums[i]].pop();
+            }
+        }
+    }
+
+    private int gcd(int a, int b) {
+        return b == 0 ? a : gcd(b, a % b);
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    vector<int> getCoprimes(vector<int>& nums, vector<vector<int>>& edges) {
+        int n = nums.size();
+        vector<vector<int>> g(n);
+        vector<vector<int>> f(51);
+        vector<stack<pair<int, int>>> stks(51);
+        for (auto& e : edges) {
+            int u = e[0], v = e[1];
+            g[u].emplace_back(v);
+            g[v].emplace_back(u);
+        }
+        for (int i = 1; i < 51; ++i) {
+            for (int j = 1; j < 51; ++j) {
+                if (__gcd(i, j) == 1) {
+                    f[i].emplace_back(j);
+                }
+            }
+        }
+        vector<int> ans(n);
+        function<void(int, int, int)> dfs = [&](int i, int fa, int depth) {
+            int t = -1, k = -1;
+            for (int v : f[nums[i]]) {
+                auto& stk = stks[v];
+                if (!stk.empty() && stk.top().second > k) {
+                    t = stk.top().first;
+                    k = stk.top().second;
+                }
+            }
+            ans[i] = t;
+            for (int j : g[i]) {
+                if (j != fa) {
+                    stks[nums[i]].push({i, depth});
+                    dfs(j, i, depth + 1);
+                    stks[nums[i]].pop();
+                }
+            }
+        };
+        dfs(0, -1, 0);
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func getCoprimes(nums []int, edges [][]int) []int {
+	n := len(nums)
+	g := make([][]int, n)
+	f := [51][]int{}
+	type pair struct{ first, second int }
+	stks := [51][]pair{}
+	for _, e := range edges {
+		u, v := e[0], e[1]
+		g[u] = append(g[u], v)
+		g[v] = append(g[v], u)
+	}
+	for i := 1; i < 51; i++ {
+		for j := 1; j < 51; j++ {
+			if gcd(i, j) == 1 {
+				f[i] = append(f[i], j)
+			}
+		}
+	}
+	ans := make([]int, n)
+	var dfs func(i, fa, depth int)
+	dfs = func(i, fa, depth int) {
+		t, k := -1, -1
+		for _, v := range f[nums[i]] {
+			stk := stks[v]
+			if len(stk) > 0 && stk[len(stk)-1].second > k {
+				t, k = stk[len(stk)-1].first, stk[len(stk)-1].second
+			}
+		}
+		ans[i] = t
+		for _, j := range g[i] {
+			if j != fa {
+				stks[nums[i]] = append(stks[nums[i]], pair{i, depth})
+				dfs(j, i, depth+1)
+				stks[nums[i]] = stks[nums[i]][:len(stks[nums[i]])-1]
+			}
+		}
+	}
+	dfs(0, -1, 0)
+	return ans
+}
+
+func gcd(a, b int) int {
+	if b == 0 {
+		return a
+	}
+	return gcd(b, a%b)
+}
 ```
 
 ### **...**