[Codeforces 986E] Prince's Problem

[题目链接]

https://codeforces.com/contest/986/problem/E

[算法]

X到Y的路径积 ， 可以转化为X到根的路径积乘Y到根的路径积 ， 除以LCA到根的路径积 ， 再除以LCA父节点到根的路径积

考虑如何计算根到X路径上每个点与Value的GCD之积

不妨对于每个质数P开一个数组cnt[] , 表示根到当前节点P^i有多少个 ， 我们可以在DFS的过程中维护这个数组

将询问离线即可

时间复杂度 ： O(V + NlogN + QlogV^2)

[代码]

#include<bits/stdc++.h>
using namespace std;
#define MAXLOG 30
const int P = 1e9 + ;
const int MAXN = 1e5 + ;
const int MAXP = 1e6 + ;
const int MAXV = 1e7 + ;

struct edge
{
        int to , nxt;
} e[MAXN << ];
struct info
{
        int value , home;
        bool type;
} ;
int tot , n , t;
int a[MAXN],depth[MAXN],prime[MAXP],head[MAXN],ans[MAXN],f[MAXV];
int cnt[MAXP][MAXLOG],anc[MAXN][MAXLOG];
vector< info > q[MAXN];

template <typename T> inline void chkmax(T &x,T y) { x = max(x,y); }
template <typename T> inline void chkmin(T &x,T y) { x = min(x,y); }
template <typename T> inline void read(T &x)
{
    T f = ; x = ;
    char c = getchar();
    for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
    for (; isdigit(c); c = getchar()) x = (x << ) + (x << ) + c - '';
    x *= f;
}
inline void addedge(int u,int v)
{
        t++;
        e[t] = (edge){v,head[u]};
        head[u] = t;
}
inline int exp_mod(int a,int n)
{
        int res =  , b = a;
        while (n > )
        {
                if (n & ) res = 1ll * res * b % P;
                b = 1ll * b * b % P;
                n >>= ;
        }
        return res;
}
inline int inv(int x) { return exp_mod(x,P - ); }
inline void dfs(int u,int fa)
{
        depth[u] = depth[fa] + ;
        for (int i = ; i < MAXLOG; i++)
        {
                if (depth[u] <= ( << i)) break;
                anc[u][i] = anc[anc[u][i - ]][i - ];
        }
        for (int i = head[u]; i; i = e[i].nxt)
        {
                int v = e[i].to;
                if (v == fa) continue;
                anc[v][] = u;
                depth[v] = depth[u] + ;
                dfs(v,u);
        }
}
inline int lca(int u,int v)
{
      if (depth[u] > depth[v]) swap(u,v);
        for (int i = MAXLOG - ; i >= ; i--)
        {
                if (depth[anc[v][i]] >= depth[u])
                        v = anc[v][i];
        }
        if (u == v) return u;
        for (int i = MAXLOG - ; i >= ; i--)
        {
                if (anc[u][i] != anc[v][i])
                        u = anc[u][i] , v = anc[v][i];
        }
        return anc[u][];
}
inline void modify(int x,int delta)
{
        for (int i = ; 1ll * prime[i] * prime[i] <= x; i++)
        {
                if (x % prime[i] == )
                {
                        int p = ;
                        while (x % prime[i] == )
                        {
                                x /= prime[i];
                                p++;
                        }
                        cnt[i][p] += delta;
                }
        }
        if (x != )
        {
                int pos = lower_bound(prime + ,prime + tot + ,x) - prime;
                cnt[pos][] += delta;
        }
}
inline int query(int x)
{
        int ret = ;
        for (int i = ; 1ll * prime[i] * prime[i] <= x; i++)
        {
                if (x % prime[i] == )
                {
                        int p = ;
                        while (x % prime[i] == )
                        {
                                p++;
                                x /= prime[i];
                        }
                        int s = ;
                        for (int j = ; j <= p; j++) s += cnt[i][j] * j;
                        for (int j = p + ; j < MAXLOG; j++) s += cnt[i][j] * p;
                        ret = 1ll * ret * exp_mod(prime[i],s) % P;
                }
         }
         if (x != )
         {
                int pos = lower_bound(prime + ,prime + tot + ,x) - prime;
                int s = ;
                for (int i = ; i < MAXLOG; i++) s += cnt[pos][i];
                ret = 1ll * ret * exp_mod(x,s) % P;
        }
        return ret;
}

inline void solve(int u,int fa)
{
        modify(a[u],);
        for (unsigned i = ; i < q[u].size(); i++)
        {
                if (q[u][i].type)    ans[q[u][i].home] = 1ll * ans[q[u][i].home] * query(q[u][i].value) % P;
                else ans[q[u][i].home] = 1ll * ans[q[u][i].home] * inv(query(q[u][i].value)) % P;
        }
        for (int i = head[u]; i; i = e[i].nxt)
        {
                int v = e[i].to;
                if (v == fa) continue;
                solve(v,u);
        }
        modify(a[u],-);
}

int main()
{

        read(n);
        for (int i = ; i < MAXV; i++)
        {
                if (!f[i])
                {
                        f[i] = i;
                        prime[++tot] = i;
                }
                for (int j = ; j <= tot; j++)
                {
                        int tmp = i * prime[j];
                        if (tmp >= MAXV) break;
                        f[tmp] = prime[j];
                        if (prime[j] == f[i]) break;
                }
        }
        for (int i = ; i < n; i++)
        {
                int u , v;
                read(u); read(v);
                addedge(u,v);
                addedge(v,u);
        }
        dfs(,);
        for (int i = ; i <= n; i++) read(a[i]);
        int Q;
        read(Q);
        for (int i = ; i <= Q; i++)
        {
                int u , v , x;
                read(u); read(v); read(x);
                int Lca = lca(u,v);
                q[u].push_back((info){x,i,true});
                q[v].push_back((info){x,i,true});
                q[Lca].push_back((info){x,i,false});
                if (Lca != ) q[anc[Lca][]].push_back((info){x,i,false});
                ans[i] = ;
        }
        solve(,);
        for (int i = ; i <= Q; i++) printf("%d\n",ans[i]);

        return ;

}