一类子树问题的总结

以下问题均允许离线，根节点都为1。

prob1 : 一棵有根树，要求线性时间求出任意子树的权值和。

prob2 : 一颗有根树，要求O(nlogn)求出与u距离不超过x且在u子树中的节点的权值和。

prob3 : 一颗有根树，要求O(nlogn)求出与u距离不超过x且在u子树中的不同颜色种类个数，颜色数不超过1E6。

prob4 : 一颗有根数，要求O(nlogn+大常数)求出与u距离不超过x且在u子树中的权值的lcm取模，节点的值不超过1E6，质因子不超过1E4。TIPS:取模后传统公式显然不成立。

（未填完）

---

Prob 1

这个问题很简单吧，找个dfs序做个前缀和就可以了。

但是dfs序却是很有用的。

没有代码。

---

Prob 2

有了限制，但我们注意到这个问题只是询问某个节点往下深度不超过x的权值和。

沿用prob1的思想，我们仍然想用前缀和，而一个节点的贡献与他的深度有关。

因此我们以深度为下标，按照dfs序依次加入可持久化线段树中，就能计算答案了。

实现太简单，没有代码。

---

Prob 3

树的问题太难了，我们先想链上问题怎么做。

现在问题的关键在于，会有重复的计数，因此我们要消除这个影响。

将询问离线下来，按照询问右端点排序，依次加入每一个点。若该点与前面有重复的，在前面的位置上减去1的贡献。

这样就转换为单点修改，区间查询，树状数组即可。

树上也同样，先求出dfs序，将询问按deppos+x排序，再依次加入每一个点。若这个点与前面的有重复，要在所有与它重复的点lca离他距离最近处减去1的贡献。

#include<bits/stdc++.h>
using namespace std;
const int maxn=1E6+5;
const int inf=INT_MAX;
int head[maxn*2],size,dfn[maxn],ti,back[maxn],fa[maxn][21],last[maxn],c[maxn],n,m,dep[maxn],ans[maxn],x,y,maxD;
struct edge{int to,next;}E[maxn*2];
struct BIT
{
    int t[maxn];
    int lowbit(int x){return x&-x;}
    void add(int x,int y){while(x<=n){t[x]+=y;x+=lowbit(x);}}
    int ask(int x){int ans=0;while(x){ans+=t[x];x-=lowbit(x);}return ans;}
}T;
struct query{int pos,d,num;}Q[maxn];
vector<int>bel[maxn];
set<int>pre[maxn];
bool cmp(query x,query y){return dep[x.pos]+x.d<dep[y.pos]+y.d;}
void add(int u,int v)
{
    E[++size].to=v;
    E[size].next=head[u];
    head[u]=size;
}
void dfs(int u,int F,int d)
{
    maxD=max(maxD,d);
    fa[u][0]=F;
    bel[d].push_back(u);
    dfn[u]=++ti;
    last[u]=back[ti]=u;
    dep[u]=d;
    for(int i=head[u];i;i=E[i].next)
    {
        int v=E[i].to;
        if(v==F)continue;
        dfs(v,u,d+1);
        last[u]=last[v];
    }
}
void init()
{
    for(int i=1;i<=20;++i)
        for(int u=1;u<=n;++u)fa[u][i]=fa[fa[u][i-1]][i-1];
}
int lca(int x,int y)
{
    if(dep[x]<dep[y])swap(x,y);
    int d=dep[x]-dep[y];
    for(int i=0;i<=20;++i)
        if(d&(1<<i))x=fa[x][i];
    if(x==y)return x;
    for(int i=20;i>=0;--i)
        if(fa[x][i]!=fa[y][i])
        {
            x=fa[x][i];
            y=fa[y][i];
        }
    return fa[x][0];
}
void insert(int x,int num)
{
    T.add(num,1);
    if(pre[x].size()==0)
    {
        pre[x].insert(num);
        pre[x].insert(inf);
        pre[x].insert(-1);
    }
    else
    {
        set<int>::iterator pr=pre[x].lower_bound(num);
        set<int>::iterator pl=pr;
        --pl;
        num=back[num];//特别注意这里，此时的num已经是节点的编号而不是dfn序了 
        if(*pl==-1)T.add(dfn[lca(back[*pr],num)],-1);
        else if(*pr==inf)T.add(dfn[lca(back[*pl],num)],-1);
        else
        {
            int u=back[*pl],v=back[*pr];
            int l1=lca(u,num),l2=lca(v,num);
            if(dep[l1]>dep[l2]) T.add(dfn[l1],-1);
            else T.add(dfn[l2],-1);
        }
        pre[x].insert(dfn[num]);
    }
}
int main()
{
    ios::sync_with_stdio(false);
    cin>>n>>m;
    for(int i=1;i<=n;++i)cin>>c[i];
    for(int i=1;i<=n-1;++i)
    {
        cin>>x>>y;
        add(x,y);
        add(y,x);
    }
    dfs(1,1,1);
    init();
    for(int i=1;i<=m;++i)
    {
        cin>>Q[i].pos>>Q[i].d;
        Q[i].num=i;
    }
    sort(Q+1,Q+m+1,cmp);
    int pos=1;
    for(int i=1;i<=n;++i)
    {
        for(int j=0;j<bel[i].size();++j)
        {
            int u=bel[i][j];
            insert(c[u],dfn[u]);
        }
        while(pos<=m&&min(dep[Q[pos].pos]+Q[pos].d,maxD)==i)
        {
            ans[Q[pos].num]=T.ask(dfn[last[Q[pos].pos]])-T.ask(dfn[Q[pos].pos]-1);
            ++pos;
        }
    }
    for(int i=1;i<=m;++i)cout<<ans[i]<<endl;
    return 0;
}

#include<bits/stdc++.h>
using namespace std;
const int maxn=1E5+5;
int n,m,head[maxn*2],size,x,y,fa[maxn],c[maxn];
set<int>ans;
struct edge{int to,next;}E[maxn*2];
void add(int u,int v)
{
    E[++size].to=v;
    E[size].next=head[u];
    head[u]=size;
}
void init(int u,int F)
{
    fa[u]=F;
    for(int i=head[u];i;i=E[i].next)
    {
        int v=E[i].to;
        if(v==F)continue;
        init(v,u);
    }
}
void dfs(int u,int F,int d)
{
    ans.insert(c[u]);
    if(d==0)return;
    for(int i=head[u];i;i=E[i].next)
    {
        int v=E[i].to;
        if(v==F)continue;
        dfs(v,u,d-1);
    }
}
int main()
{
    ios::sync_with_stdio(false);
    cin>>n>>m;
    for(int i=1;i<=n;++i)cin>>c[i];
    for(int i=1;i<=n-1;++i)
    {
        cin>>x>>y;
        add(x,y);
        add(y,x);
    }
    init(1,1);
    while(m--)
    {
        cin>>x>>y;
        ans.clear();
        dfs(x,fa[x],y);
        cout<<ans.size()<<endl;
    }
    return 0;
}

 （未填完）

---

Prob 4

树的问题太难了，我们先想链上问题怎么做。

链上问题还是太难了，我们先考虑只有质数怎么做。

只有质数的话，就转化为Prob3了。

再考虑链上一般的情况。我们只要把每个数质因式分解，对于固定的质数p以及它的次数k，看将它看做1~k种颜色的“和”。如：

其余的类似。

这样继续沿用Prob3，可以推广到树上。开个set就行了。

代码看博主心情。