[bzoj5457]城市

传送门

这个题有多种解法，如虚树，分治，线段树合并，平衡树启发式合并，dsu on tree
我采用了dsu on tree和线段树合并来解决这个题目
很显然能看出这个题和维护子树信息有关
dsu on tree相信大家都知道是一种处理子树信息的优秀算法，利用轻重链剖分的优秀性质，
我们可以爆搜轻链，但是每次保留重链的信息，这样时间复杂度就是优秀的(O(nlogn))
代码（dsu on tree）：

#include<cstdio>
#include<iostream>
#include<algorithm>
using namespace std;
void read(int &x) {
    char ch; bool ok;
    for(ok=0,ch=getchar(); !isdigit(ch); ch=getchar()) if(ch=='-') ok=1;
    for(x=0; isdigit(ch); x=x*10+ch-'0',ch=getchar()); if(ok) x=-x;
}
#define rg register
const int maxn=4e5+1;
int heavy[maxn],dep[maxn],size[maxn],n,m,cnt,pre[maxn*2],nxt[maxn*2],h[maxn],ans[maxn],ans1[maxn],a[maxn],b[maxn],t[maxn],now,nnow;
inline void add(int x,int y)
{
    pre[++cnt]=y,nxt[cnt]=h[x],h[x]=cnt;
    pre[++cnt]=x,nxt[cnt]=h[y],h[y]=cnt;
}
inline void dfs(int x,int fa)
{
    size[x]=1;
    for(rg int i=h[x];i;i=nxt[i])
        if(pre[i]!=fa)dep[pre[i]]=dep[x]+1,dfs(pre[i],x),size[x]+=size[pre[i]];
}
inline void dfs1(int x)
{
    for(rg int i=h[x];i;i=nxt[i])
        if(dep[pre[i]]>dep[x]&&size[pre[i]]>size[heavy[x]])heavy[x]=pre[i];
    if(heavy[x])dfs1(heavy[x]);
    for(rg int i=h[x];i;i=nxt[i])
        if(dep[pre[i]]>dep[x]&&pre[i]!=heavy[x])dfs1(pre[i]);
}
inline void clear(int x,int fa)
{
    t[a[x]]-=b[x];
    for(rg int i=h[x];i;i=nxt[i])if(pre[i]!=fa)clear(pre[i],x);
}
inline void get(int x)
{
    t[a[x]]+=b[x];
    if(t[a[x]]>t[now]||(t[a[x]]==t[now]&&a[x]<now))now=a[x],nnow=t[a[x]];
}
inline void ins(int x,int fa)
{
    get(x);
    for(rg int i=h[x];i;i=nxt[i])if(pre[i]!=fa)ins(pre[i],x);
}
inline void dsu(int x,int fa)
{
    for(rg int i=h[x];i;i=nxt[i])
        if(pre[i]!=fa&&heavy[x]!=pre[i])dsu(pre[i],x),clear(pre[i],x);
    if(heavy[x])dsu(heavy[x],x);get(x);
    for(rg int i=h[x];i;i=nxt[i])
        if(pre[i]!=fa&&heavy[x]!=pre[i])ins(pre[i],x);
    ans[x]=now,ans1[x]=t[now];
}
int main()
{
    read(n),read(m);
    for(rg int i=1,x,y;i<n;i++)read(x),read(y),add(x,y);
    for(rg int i=1;i<=n;i++)read(a[i]),read(b[i]);
    dfs(1,0),dfs1(1),dsu(1,0);
    for(rg int i=1;i<=n;i++)printf("%d %d
",ans[i],ans1[i]);
}

线段树合并也能解决这个问题，对于每个节点建一颗线段树，从叶子节点开始合并，每次合并复杂度为(O(logn))，然后更新答案，总时间复杂度为(O(nlog_2n))，空间复杂度为(O(nlogn))（动态开点）
代码（线段树合并）：

#include<cstdio>
#include<algorithm>
int f[400001],n,m,pre[800001],cnt,rt[400001],ls[10000001],rs[10000001],nxt[800001],h[400001],a[400001],b[400001],id,sum[10000001],pw[10000001],ans[400001],ans1[400001];
void add(int x,int y)
{
    pre[++cnt]=y;nxt[cnt]=h[x];h[x]=cnt;
    pre[++cnt]=x;nxt[cnt]=h[y];h[y]=cnt;
}
void update(int x)
{
    if(sum[ls[x]]>sum[rs[x]])sum[x]=sum[ls[x]],pw[x]=pw[ls[x]];
    else if(sum[ls[x]]==sum[rs[x]])sum[x]=sum[ls[x]],pw[x]=std::min(pw[ls[x]],pw[rs[x]]);
    else sum[x]=sum[rs[x]],pw[x]=pw[rs[x]];
}
void build(int &k,int l,int r,int v)
{
    if(!k)k=++id;
    if(l==r){sum[k]+=b[v];pw[k]=a[v];return ;}
    int mid=(l+r)>>1;
    if(a[v]<=mid)build(ls[k],l,mid,v);
    else build(rs[k],mid+1,r,v);
    update(k);
}
int merge(int x,int y,int l,int r)
{
    if(!x||!y)return x+y;
    if(l==r){sum[x]=sum[x]+sum[y];return x;}
    ls[x]=merge(ls[x],ls[y],l,(l+r)>>1);
    rs[x]=merge(rs[x],rs[y],((l+r)>>1)+1,r);
    update(x);return x;
}
void dfs(int x,int fa)
{
    for(int i=h[x];i;i=nxt[i])if(pre[i]!=fa)dfs(pre[i],x);
    build(rt[x],1,m,x);
    for(int i=h[x];i;i=nxt[i])if(pre[i]!=fa)rt[x]=merge(rt[x],rt[pre[i]],1,m);
    ans[x]=sum[rt[x]];ans1[x]=pw[rt[x]];
}
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1,x,y;i<n;i++)scanf("%d%d",&x,&y),add(x,y);
    for(int i=1;i<=n;i++)scanf("%d%d",&a[i],&b[i]);
    dfs(1,0);for(int i=1;i<=n;i++)printf("%d %d
",ans1[i],ans[i]);
}