【BZOJ3730】震波（动态点分治）[复习]

题面

BZOJ

题解

动态点分治什么的完全不记得了。这回重新写一写。
首先我们把点分树给建出来。
操作只有两种，修改和询问距离某个点的距离不超过\(k\)的点的和。
两点之间的距离可以树链剖分之类的算，这里不再重复。
考虑如何计算答案。
对于每个点，把对于它的点分树上所有祖先的贡献给加好。
因为要方便区间求和，所以利用动态开点线段树实现。
假设当前点距离点分树上某祖先的距离为\(dis\)，那么就把这个祖先的线段树的\(dis\)位置加上当前点的权值。
每次询问的时候只需要沿着点分树的父亲走，然后每次询问线段树上\([0,k-dis(fa,u)]\)的和就好了。
但是这样有个问题，对于当前点的子树，它的贡献会在所有点分树上的祖先位置被重复计算。
所以我们再额外维护一棵线段树，表示当前点的所有子树中，对于它点分树父亲的贡献，
这样子每次把重复算的给减去就好了。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<set>
#include<map>
#include<vector>
#include<queue>
using namespace std;
#define ll long long
#define RG register
#define MAX 111111
inline int read()
{
    RG int x=0,t=1;RG char ch=getchar();
    while((ch<'0'||ch>'9')&&ch!='-')ch=getchar();
    if(ch=='-')t=-1,ch=getchar();
    while(ch<='9'&&ch>='0')x=x*10+ch-48,ch=getchar();
    return x*t;
}
int n,m,V[MAX];
struct Line{int v,next;}e[MAX<<1];
int h[MAX],cnt=1;
inline void Add(int u,int v){e[cnt]=(Line){v,h[u]};h[u]=cnt++;}
/********************************************************************/
int size[MAX],dfn[MAX],top[MAX],dep[MAX],fa[MAX],tim,hson[MAX];
void dfs1(int u,int ff)
{
    fa[u]=ff;size[u]=1;dep[u]=dep[ff]+1;
    for(int i=h[u];i;i=e[i].next)
    {
        int v=e[i].v;if(v==ff)continue;
        dfs1(v,u);size[u]+=size[v];
        if(size[v]>size[hson[u]])hson[u]=v;
    }
}
void dfs2(int u,int tp)
{
    top[u]=tp;
    if(hson[u])dfs2(hson[u],tp);
    for(int i=h[u];i;i=e[i].next)
        if(e[i].v!=fa[u]&&e[i].v!=hson[u])
            dfs2(e[i].v,e[i].v);
}
int LCA(int u,int v)
{
    while(top[u]^top[v])dep[top[u]]<dep[top[v]]?v=fa[top[v]]:u=fa[top[u]];
    return dep[u]<dep[v]?u:v;
}
int Dis(int u,int v){return dep[u]+dep[v]-2*dep[LCA(u,v)];}
/********************************************************************/
bool vis[MAX];
int Fa[MAX],Size,root,mx;
void Getroot(int u,int ff)
{
    size[u]=1;int ret=0;
    for(int i=h[u];i;i=e[i].next)
    {
        int v=e[i].v;if(v==ff||vis[v])continue;
        Getroot(v,u);size[u]+=size[v];
        ret=max(ret,size[v]);
    }
    ret=max(ret,Size-size[u]);
    if(ret<mx)mx=ret,root=u;
}
void DFS(int u,int ff)
{
    vis[u]=true;Fa[u]=ff;
    for(int i=h[u];i;i=e[i].next)
    {
        int v=e[i].v;if(vis[v])continue;
        mx=Size=size[v];
        Getroot(v,u);DFS(root,u);
    }
}
/********************************************************************/
int rt[MAX<<1],tot;
struct Node{int ls,rs,v;}t[MAX<<6];
void Modify(int &x,int l,int r,int p,int w)
{
    if(!x)x=++tot;t[x].v+=w;if(l==r)return;
    int mid=(l+r)>>1;
    if(p<=mid)Modify(t[x].ls,l,mid,p,w);
    else Modify(t[x].rs,mid+1,r,p,w);
}
int Query(int x,int l,int r,int L,int R)
{
    if(!x)return 0;if(L<=l&&r<=R)return t[x].v;
    int mid=(l+r)>>1,ret=0;
    if(L<=mid)ret+=Query(t[x].ls,l,mid,L,R);
    if(R>mid)ret+=Query(t[x].rs,mid+1,r,L,R);
    return ret;
}
/********************************************************************/
void Modify(int x,int w)
{
    Modify(rt[x],0,n,0,w);
    for(int i=x;Fa[i];i=Fa[i])
    {
        int dis=Dis(x,Fa[i]);
        Modify(rt[Fa[i]],0,n,dis,w);
        Modify(rt[i+n],0,n,dis,w);
    }
}
int Query(int x,int K)
{
    int ret=Query(rt[x],0,n,0,K);
    for(int i=x;Fa[i];i=Fa[i])
    {
        int dis=Dis(x,Fa[i]);if(dis>K)continue;
        ret+=Query(rt[Fa[i]],0,n,0,K-dis);
        ret-=Query(rt[i+n],0,n,0,K-dis);
    }
    return ret;
}
/********************************************************************/
int main()
{
    n=read();m=read();
    for(int i=1;i<=n;++i)V[i]=read();
    for(int i=1;i<n;++i)
    {
        int u=read(),v=read();
        Add(u,v);Add(v,u);
    }
    dfs1(1,0);dfs2(1,1);
    Size=mx=n;Getroot(1,0);DFS(root,0);
    for(int i=1;i<=n;++i)Modify(i,V[i]);
    int ans=0;
    while(m--)
    {
        int opt=read(),x=read()^ans,y=read()^ans;
        if(opt==0)printf("%d\n",ans=Query(x,y));
        else Modify(x,y-V[x]),V[x]=y;
    }
    return 0;
}

转载于:https://www.cnblogs.com/cjyyb/p/9309615.html