[jzoj 6086] [GDOI2019模拟2019.3.26] 动态半平面交 解题报告 (set+线段树)

题目链接：

https://jzoj.net/senior/#main/show/6086

题目：

题解：

• 一群数字的最小公倍数就是对它们质因数集合中的每个质因数的指数取$max$然后相乘
• 这样的子树查询一般都与$dfs$序有关
• 不妨把一个质因数$p$拆分成$p^1,p^2,p^3...$这样若干种颜色，每种颜色对答案的贡献都是$p$
• 我们从另一个角度来考虑如何处理“不同的数”。先不管深度，考虑两个点权相等的节点$u$和$v$，点权为$val$，他们自己的贡献是使得所有子树内包含他的节点答案乘以$val$，现在考虑重复了的贡献，同时包含$u$和$v$的节点答案被乘了两次，即包含$lca(u,v)$的节点答案需要被除去一个$val$。
• 多个节点的时候，只需按$dfs$序排序，相邻两个的$lca$处除即可。现在我们要考虑深度，只需要将询问离线并按深度排序，节点按深度排序后一个一个加入即可。维护点权相同的点可以用$set$，维护$dfs$序用线段树。这是一个很经典的做法
• 在线的话，把线段树可持久化即可

代码：

#include<algorithm>
#include<cstring>
#include<cstdio>
#include<iostream>
#include<cmath>
#include<set>
#include<map>
using namespace std;
typedef long long ll;

const int N=1e5+;
const int M=1e7+;
const int mo=;
int n,tot;
int a[N],head[N];
set <int> s[N*];
map<int,int>hsh;
struct EDGE
{
    int to,nxt;
}edge[N<<];
inline int read()
{
    char ch=getchar();int s=,f=;
    while (ch<''||ch>'') {if (ch=='-') f=-;ch=getchar();}
    while (ch>=''&&ch<='') {s=(s<<)+(s<<)+ch-'';ch=getchar();}
    return s*f;
}
int cnt;
int prime[M],mn[M],vis[M];
void pre()
{
    mn[]=;
    for (int i=;i<M;i++)
    {
        if (!vis[i]) prime[++cnt]=i,mn[i]=i;
        for (int j=;j<=cnt&&prime[j]*i<M;j++)
        {
            vis[prime[j]*i]=;mn[prime[j]*i]=prime[j];
            if (i%prime[j]==) break;
        }
    }
}
int qpow(int a,int b)
{
    int re=;
    for (;b;b>>=,a=1ll*a*a%mo) if (b&) re=1ll*re*a%mo;
    return re;
}
void add(int u,int v)
{
    edge[++tot]=(EDGE){v,head[u]};
    head[u]=tot;
}
int tim;
int fa[N][],st[N],ed[N],dep[N],tid[N];
void dfs(int x,int p)
{
    dep[x]=dep[p]+;
    st[x]=++tim;tid[tim]=x;
    fa[x][]=p;
    for (int i=;i<=;i++) fa[x][i]=fa[fa[x][i-]][i-];
    for (int i=head[x];i;i=edge[i].nxt)
    {
        int y=edge[i].to;
        if (y==p) continue;
        dfs(y,x);
    }
    ed[x]=tim;
}
int lca(int x,int y)
{
    if (dep[x]<dep[y]) swap(x,y);
    for (int i=;i>=;i--) if (dep[fa[x][i]]>=dep[y]) x=fa[x][i];
    if (x==y) return x;
    for (int i=;i>=;i--) if (fa[x][i]!=fa[y][i]) x=fa[x][i],y=fa[y][i];
    return fa[x][];
}
bool cmp(const int &a,const int &b) {return dep[a]<dep[b];}
int idx;
int get(int x)
{
    if (!hsh[x]) hsh[x]=++idx;
    return hsh[x];
}
int sz;
int rt[N],mul[N*],ls[N*],rs[N*];
void ins(int &o,int lst,int l,int r,int x,int y)
{
    o=++sz;
    mul[o]=1ll*mul[lst]*y%mo;
    ls[o]=ls[lst];rs[o]=rs[lst];
    if (l==r) return;
    int mid=l+r>>;
    if (x<=mid) ins(ls[o],ls[lst],l,mid,x,y);
    else ins(rs[o],rs[lst],mid+,r,x,y);
}
int query(int o,int l,int r,int x,int y)
{
    if (l>=x&&r<=y) return mul[o];
    int mid=l+r>>,re=;
    if (x<=mid) re=1ll*re*query(ls[o],l,mid,x,y)%mo;
    if (y>mid) re=1ll*re*query(rs[o],mid+,r,x,y)%mo;
    return re;
}
int b[N];
int main()
{
    freopen("half.in","r",stdin);
    freopen("half.out","w",stdout);
    pre();
    int k=read();n=read();
    for (int i=;i<=n;i++) a[i]=read(),b[i]=i;
    for (int i=;i<n;i++)
    {
        int u=read(),v=read();
        add(u,v);add(v,u);
    }
    dfs(,);
    mul[]=;
    sort(b+,b++n,cmp);
    set<int>::iterator it1,it2,it3;
    for (int i=;i<=n;i++)
    {
        int u=b[i],d=dep[u],tmp=a[u];
        rt[d]=rt[dep[b[i-]]];
        while (tmp>)
        {
            int t=mn[tmp],it=qpow(t,mo-),z=;
            while (tmp%t==)
            {
                tmp/=t;
                z*=t;
                int y=get(z);
                s[y].insert(st[u]);
                it2=s[y].lower_bound(st[u]);
                it1=it2;
                if (it1!=s[y].begin()) --it1;
                it3=it2;
                ++it3;
                ins(rt[d],rt[d],,n,st[u],t);
                int u1=,u2=;
                if (it2!=s[y].begin())
                {
                    u1=tid[*it1];int L=lca(u1,u);
                    ins(rt[d],rt[d],,n,st[L],it);
                }
                if (it3!=s[y].end())
                {
                    u2=tid[*it3];int L=lca(u2,u);
                    ins(rt[d],rt[d],,n,st[L],it);
                }
                if (u1&&u2)
                {
                    int L=lca(u1,u2);
                    ins(rt[d],rt[d],,n,st[L],t);
                }
            }
        }
    }
    for (int i=dep[b[n]]+;i<=n;i++) rt[i]=rt[i-];
    int q=read(),ans=;
    while (q--)
    {
        int u=read()^(k*ans),d=min(n,dep[u]+read()^(k*ans));
        printf("%d\n",query(rt[d],,n,st[u],ed[u]));
    }
    return ;
}