在N元树中查找给定节点的每个子树的GCD，以进行Q查询

在一棵N元树中，给定一个节点，需要查找该节点的每个子树的GCD，并支持进行多个查询。这个问题实际上是在一个树形结构上计算每个子树内的数值的最大公约数，可以通过树形DP或欧几里得算法（辗转相除法）来解决。

树形DP

算法思想

在树形DP中，我们为每个节点维护两个数组，一个是以该节点为根的子树中各个数值的最大公约数，另一个是经过该节点的非树边所连接的节点的数值，我们称为祖先节点。这两个数组可以通过子节点的信息来计算，并且可以在查询时使用。

具体算法如下：

1. 对于每个节点，将其初始化为该节点的数值。
2. 对于每个子节点，递归计算子节点的信息，并更新该节点的各个数组。
3. 对于每个查询，获取需要查询的节点以及其祖先节点，并使用它们的数组信息进行计算。

代码实现

代码实现需要定义一个递归函数 dfs，该函数用于计算每个子节点的信息，并且更新当前节点的各个数组。同时，还需要定义一个查询函数 query，用于获取查询节点的信息，并利用之前计算好的数组信息计算GCD。

#include <iostream>
#include <vector>

using namespace std;

const int MAXN = 1e5+5;

int n, q;
int a[MAXN], gcd[MAXN][25], anc[MAXN][25];
vector<int> tree[MAXN];

// 计算子节点的信息
void dfs(int u, int p) {
    // 初始化该节点的信息
    gcd[u][0] = a[u];
    anc[u][0] = p;

    // 计算子节点的信息
    for (int i = 1; i <= 20; i++) {
        int v = anc[u][i-1];
        if (v == -1) break;
        gcd[u][i] = __gcd(gcd[u][i-1], gcd[v][i-1]);
        anc[u][i] = anc[v][i-1];
    }

    for (int v : tree[u]) {
        if (v != p) dfs(v, u);
    }
}

// 查询某个节点的信息
int query(int u, int v) {
    int ans = a[u];
    while (u != v) {
        if (v == -1) break;
        for (int i = 20; i >= 0; i--) {
            if (anc[u][i] != -1 && anc[u][i] != anc[v][i]) {
                ans = __gcd(ans, gcd[u][i]);
                ans = __gcd(ans, gcd[v][i]);
                u = anc[u][i];
                v = anc[v][i];
                break;
            }
        }
        if (u != v) {
            ans = __gcd(ans, a[v]);
            v = anc[v][0];
        }
    }
    return ans;
}

int main() {
    cin >> n >> q;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }
    for (int i = 1; i < n; i++) {
        int u, v;
        cin >> u >> v;
        tree[u].push_back(v);
        tree[v].push_back(u);
    }

    // 初始化根节点的祖先节点为-1
    for (int i = 1; i <= n; i++) anc[i][0] = -1;

    // 计算每个节点的信息
    dfs(1, -1);

    // 进行多个查询
    while (q--) {
        int u, v;
        cin >> u >> v;
        cout << query(u, v) << endl;
    }

    return 0;
}

欧几里得算法（辗转相除法）

算法思想

在欧几里得算法中，我们可以通过求解两个数的最大公约数，来求解多个数的最大公约数。具体来说，假设 gcd(a, b) 表示两个数 a 和 b 的最大公约数，则 gcd(a, b, c) 可以表示为 gcd(gcd(a, b), c)。因此，我们可以对于每个节点的数值，对其所有父节点的数值求解最大公约数，从而得到该节点所在子树中所有数值的最大公约数。

代码实现

代码实现需要定义一个递归函数 dfs，该函数用于计算当前节点的所有父节点的数值，并计算该节点所在子树中的所有数值的最大公约数。同时，还需要定义一个查询函数 query，用于获取查询节点所在的子树中所有数值的最大公约数。

#include <iostream>
#include <vector>

using namespace std;

const int MAXN = 1e5+5;

int n, q;
int a[MAXN], ans[MAXN];
vector<int> tree[MAXN];

// 计算当前节点父节点的信息，并计算子树的GCD
void dfs(int u, int p) {
    ans[u] = a[u];
    for (int v : tree[u]) {
        if (v != p) {
            dfs(v, u);
            ans[u] = __gcd(ans[u], ans[v]);
        }
    }
}

// 查询子树中的GCD值
int query(int u) {
    return ans[u];
}

int main() {
    cin >> n >> q;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }
    for (int i = 1; i < n; i++) {
        int u, v;
        cin >> u >> v;
        tree[u].push_back(v);
        tree[v].push_back(u);
    }

    // 计算每个节点所在子树的GCD
    dfs(1, -1);

    // 进行多个查询
    while (q--) {
        int u;
        cin >> u;
        cout << query(u) << endl;
    }

    return 0;
}

总结

本文介绍了在N元树中查找给定节点的每个子树的GCD的两种算法，使用树形DP和欧几里得算法（辗转相除法）分别解决了这个问题。树形DP算法的思路清晰，代码实现相对较为复杂，而欧几里得算法的实现相对简单，但是对于较为复杂的树结构，可能需要使用树形DP算法。