LeetCode
互质树
题目链接：1766. 互质树 - 力扣（LeetCode）
题目描述
给你一个 n 个节点的树（也就是一个无环连通无向图），节点编号从 0 到 n - 1 ，且恰好有 n - 1 条边，每个节点有一个值。树的 根节点 为 0 号点。
给你一个整数数组 nums 和一个二维数组 edges 来表示这棵树。nums[i] 表示第 i 个点的值，edges[j] = [uj, vj] 表示节点 uj 和节点 vj 在树中有一条边。
当 gcd(x, y) == 1 ，我们称两个数 x 和 y 是 互质的 ，其中 gcd(x, y) 是 x 和 y 的 最大公约数 。
从节点 i 到 根 最短路径上的点都是节点 i 的祖先节点。一个节点 不是 它自己的祖先节点。
请你返回一个大小为 n 的数组 ans ，其中 ans[i]是离节点 i 最近的祖先节点且满足 nums[i] 和 nums[ans[i]] 是 互质的 ，如果不存在这样的祖先节点，ans[i] 为 -1 。
示例 1：
输入：nums = [2,3,3,2], edges = [[0,1],[1,2],[1,3]]
输出：[-1,0,0,1]
解释：上图中，每个节点的值在括号中表示。
- 节点 0 没有互质祖先。
- 节点 1 只有一个祖先节点 0 。它们的值是互质的（gcd(2,3) == 1）。
- 节点 2 有两个祖先节点，分别是节点 1 和节点 0 。节点 1 的值与它的值不是互质的（gcd(3,3) == 3）但节点 0 的值是互质的(gcd(2,3) == 1)，所以节点 0 是最近的符合要求的祖先节点。
- 节点 3 有两个祖先节点，分别是节点 1 和节点 0 。它与节点 1 互质（gcd(3,2) == 1），所以节点 1 是离它最近的符合要求的祖先节点。
示例 2：
输入：nums = [5,6,10,2,3,6,15], edges = [[0,1],[0,2],[1,3],[1,4],[2,5],[2,6]]
输出：[-1,0,-1,0,0,0,-1]
提示：
nums.length == n1 <= nums[i] <= 501 <= n <= 105edges.length == n - 1edges[j].length == 20 <= uj, vj < nuj != vj
思路
困难题，cv大法
代码
C++
const int MX = 51;
vector<int> coprime[MX];
auto init = [] {
// 预处理：coprime[i] 保存 [1, MX) 中与 i 互质的所有元素
for (int i = 1; i < MX; i++) {
for (int j = 1; j < MX; j++) {
if (gcd(i, j) == 1) {
coprime[i].push_back(j);
}
}
}
return 0;
}();
class Solution {
vector<vector<int>> g;
vector<int> ans;
pair<int, int> val_depth_id[MX]; // 包含深度和节点编号
void dfs(int x, int fa, int depth, vector<int> &nums) {
int val = nums[x]; // x 的节点值
// 计算与 val 互质的数中，深度最大的节点编号
int max_depth = 0;
for (int j : coprime[val]) {
auto [depth, id] = val_depth_id[j];
if (depth > max_depth) {
max_depth = depth;
ans[x] = id;
}
}
auto tmp = val_depth_id[val]; // 用于恢复现场
val_depth_id[val] = {depth, x}; // 保存 val 对应的节点深度和节点编号
for (int y : g[x]) {
if (y != fa) {
dfs(y, x, depth + 1, nums);
}
}
val_depth_id[val] = tmp; // 恢复现场
}
public:
vector<int> getCoprimes(vector<int> &nums, vector<vector<int>> &edges) {
int n = nums.size();
g.resize(n);
for (auto &e : edges) {
int x = e[0], y = e[1];
g[x].push_back(y);
g[y].push_back(x);
}
ans.resize(n, -1);
dfs(0, -1, 1, nums);
return ans;
}
};
Java
class Solution {
private static final int MX = 51;
private static final int[][] coprime = new int[MX][MX];
static {
// 预处理
// coprime[i] 保存 [1, MX) 中与 i 互质的所有元素
for (int i = 1; i < MX; i++) {
int k = 0;
for (int j = 1; j < MX; j++) {
if (gcd(i, j) == 1) {
coprime[i][k++] = j;
}
}
}
}
public int[] getCoprimes(int[] nums, int[][] edges) {
int n = nums.length;
List<Integer>[] g = new ArrayList[n];
Arrays.setAll(g, i -> new ArrayList<>());
for (int[] e : edges) {
int x = e[0];
int y = e[1];
g[x].add(y);
g[y].add(x);
}
int[] ans = new int[n];
Arrays.fill(ans, -1);
int[] valDepth = new int[MX];
int[] valNodeId = new int[MX];
dfs(0, -1, 1, g, nums, ans, valDepth, valNodeId);
return ans;
}
private void dfs(int x, int fa, int depth, List<Integer>[] g, int[] nums, int[] ans, int[] valDepth, int[] valNodeId) {
// x 的节点值
int val = nums[x];
// 计算与 val 互质的祖先节点值中，节点深度最大的节点编号
int maxDepth = 0;
for (int j : coprime[val]) {
if (j == 0) {
break;
}
if (valDepth[j] > maxDepth) {
maxDepth = valDepth[j];
ans[x] = valNodeId[j];
}
}
// tmpDepth 和 tmpNodeId 用于恢复现场
int tmpDepth = valDepth[val];
int tmpNodeId = valNodeId[val];
// 保存 val 对应的节点深度和节点编号
valDepth[val] = depth;
valNodeId[val] = x;
// 向下递归
for (int y : g[x]) {
if (y != fa) {
dfs(y, x, depth + 1, g, nums, ans, valDepth, valNodeId);
}
}
// 恢复现场
valDepth[val] = tmpDepth;
valNodeId[val] = tmpNodeId;
}
private static int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
}
