Description#
There is a tree (i.e., a connected, undirected graph that has no cycles) consisting of n nodes numbered from 0 to n - 1 and exactly n - 1 edges. Each node has a value associated with it, and the root of the tree is node 0.
To represent this tree, you are given an integer array nums and a 2D array edges. Each nums[i] represents the ith node's value, and each edges[j] = [uj, vj] represents an edge between nodes uj and vj in the tree.
Two values x and y are coprime if gcd(x, y) == 1 where gcd(x, y) is the greatest common divisor of x and y.
An ancestor of a node i is any other node on the shortest path from node i to the root. A node is not considered an ancestor of itself.
Return an array ans of size n, where ans[i] is the closest ancestor to node i such that nums[i] and nums[ans[i]] are coprime, or -1 if there is no such ancestor.
Example 1:
Input: nums = [2,3,3,2], edges = [[0,1],[1,2],[1,3]]
Output: [-1,0,0,1]
Explanation: In the above figure, each node's value is in parentheses.
- Node 0 has no coprime ancestors.
- Node 1 has only one ancestor, node 0. Their values are coprime (gcd(2,3) == 1).
- Node 2 has two ancestors, nodes 1 and 0. Node 1's value is not coprime (gcd(3,3) == 3), but node 0's
value is (gcd(2,3) == 1), so node 0 is the closest valid ancestor.
- Node 3 has two ancestors, nodes 1 and 0. It is coprime with node 1 (gcd(3,2) == 1), so node 1 is its
closest valid ancestor.
Example 2:
Input: nums = [5,6,10,2,3,6,15], edges = [[0,1],[0,2],[1,3],[1,4],[2,5],[2,6]]
Output: [-1,0,-1,0,0,0,-1]
Constraints:
nums.length == n1 <= nums[i] <= 501 <= n <= 105edges.length == n - 1edges[j].length == 20 <= uj, vj < nuj != vj
Solutions#
Solution 1#
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| 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
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
| 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);
}
}
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
| 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;
}
};
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
| 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)
}
|
