BZOJ 4372/3370 烁烁的游戏/震波 (动态点分治+线段树)

烁烁的游戏 题目大意：

给你一棵$n$个节点的树，有$m$次操作，询问某个节点的权值，或者将与某个点$x$距离不超过$d$的所有节点的权值都增加$w$

动态点分裸题

每个节点开一棵权值线段树

对于修改操作，它从$x$开始，像一个涟漪扩散，对它周围与它距离$\leq d$的所有节点造成$w$点贡献

为了记录这个操作的贡献，我们寻找树分治每一层中 包含这个节点的那个点分树的重心$root$

在$root$处记录贡献，开一棵动态开点权值线段树，记录与这个节点距离为$d$的贡献总和，显然在$root$周围扩散范围是$d-dis(x,root)$

还要去掉包含$x$子树的贡献，所以每个节点要再开一个，记录对于父重心需要去掉的贡献

每次查询都沿着点分重心往上跳，因为修改的过程是在线段树上打差分，所以在当前重心查询$d-dis(x,root)$的后缀和即可

由于每次修改都要不断网上跳重心，一共要修改$log$次，每次都要求距离，所以采用欧拉序求$LCA$减小常数

空间是$O(nlog^{2}n)$的，容易被卡，记录当前节点最大能扩散的范围，即当前节点接管的那部分子树内节点的最大深度，非常有效地优化了空间

实在是讲不太明白，大家可以看代码

 #include <map>
 #include <queue>
 #include <vector>
 #include <cstdio>
 #include <cstring>
 #include <algorithm>
 #define N1 101000
 #define ll long long
 #define dd double
 #define inf 0x3f3f3f3f3f3f3f3fll
 using namespace std;

 int gint()
 {
     int ret=,fh=;char c=getchar();
     while(c<''||c>''){if(c=='-')fh=-;c=getchar();}
     while(c>=''&&c<=''){ret=ret*+c-'';c=getchar();}
     return ret*fh;
 }

 struct SEG{
 int sum[N1*],ls[N1*],rs[N1*],rm[N1],rf[N1],tot;
 void pushup(int rt){sum[rt]=sum[ls[rt]]+sum[rs[rt]];}
 void update(int x,int l,int r,int &rt,int w)
 {
     if(!rt) rt=++tot;
     if(l==r) {sum[rt]+=w;return;}
     int mid=(l+r)>>;
     if(x<=mid) update(x,l,mid,ls[rt],w);
     else update(x,mid+,r,rs[rt],w);
     pushup(rt);
 }
 int query(int L,int R,int l,int r,int rt)
 {
     if(!rt) return ;
     if(L<=l&&r<=R) return sum[rt];
     int mid=(l+r)>>,ans=;
     if(L<=mid) ans+=query(L,R,l,mid,ls[rt]);
     if(R>mid) ans+=query(L,R,mid+,r,rs[rt]);
     return ans;
 }
 }s;

 struct Edge{
 int to[N1<<],nxt[N1<<],head[N1],cte;
 void ae(int u,int v)
 {cte++;to[cte]=v,nxt[cte]=head[u],head[u]=cte;}
 }e;

 int n,m,T;
 namespace tr{
 int dep[N1],ff[N1<<][],st[N1],id[N1<<],lg[N1<<],tot;
 void dfs1(int u,int dad)
 {
     id[++tot]=u; st[u]=tot; ff[tot][]=u;
     for(int j=e.head[u];j;j=e.nxt[j])
     {
         int v=e.to[j]; if(v==dad) continue;
         dep[v]=dep[u]+; dfs1(v,u); id[++tot]=u; ff[tot][]=u;
     }
 }
 void get_st()
 {
     int i,j;
     for(lg[]=,i=;i<=tot;i++) lg[i]=lg[i>>]+;
     for(j=;j<=lg[tot];j++)
         for(i=;i+(<<j)-<=tot;i++)
         ff[i][j]=dep[ ff[i][j-] ]<dep[ ff[i+(<<(j-))][j-] ]?ff[i][j-]:ff[i+(<<(j-))][j-];
 }
 int dis(int x,int y)
 {
     int tx=min(st[x],st[y]),ty=max(st[x],st[y]),L=ty-tx+;
     int fa=dep[ ff[tx][lg[L]] ]<dep[ ff[ty-(<<lg[L])+][lg[L]] ]?ff[tx][lg[L]]:ff[ty-(<<lg[L])+][lg[L]];
     return dep[x]+dep[y]-*dep[fa];
 }
 void init(){dfs1(,-);get_st();}
 };

 using tr::dis;

 int ms[N1],sz[N1],dep[N1],mad[N1],use[N1],fa[N1],tsz,G;
 void dfs(int u,int dad,int g)
 {
     mad[g]=max(mad[g],dep[u]); sz[u]=;
     for(int j=e.head[u];j;j=e.nxt[j])
     {
         int v=e.to[j]; if(v==dad||use[v]) continue;
         dep[v]=dep[u]+; dfs(v,u,g); sz[u]+=sz[v];
     }
 }
 void gra(int u,int dad)
 {
     sz[u]=; ms[u]=;
     for(int j=e.head[u];j;j=e.nxt[j])
     {
         int v=e.to[j]; if(use[v]||v==dad) continue;
         gra(v,u); sz[u]+=sz[v]; ms[u]=max(ms[u],sz[v]);
     }
     ms[u]=max(ms[u],tsz-sz[u]);
     if(ms[u]<ms[G]) G=u;
 }
 void main_dfs(int u)
 {
     use[u]=; dep[u]=; dfs(u,-,u);
     for(int j=e.head[u];j;j=e.nxt[j])
     {
         int v=e.to[j]; if(use[v]) continue;
         G=; tsz=sz[v]; gra(v,-); fa[G]=u;
         main_dfs(G);
     }
 }
 void modify(int x,int K,int w)
 {
     int i,D;
     for(i=x;i;i=fa[i])
     {
         D=dis(x,i);
         if(D<=K) s.update(min(mad[i],K-D),,mad[i],s.rm[i],w);
         if(!fa[i]) break;
         D=dis(x,fa[i]);
         if(D<=K) s.update(min(mad[fa[i]],K-D),,mad[fa[i]],s.rf[i],w);
     }
 }
 int query(int x)
 {
     int i,D,ans=;
     for(i=x;i;i=fa[i])
     {
         D=dis(x,i);
         if(D<=mad[i]) ans+=s.query(D,mad[i],,mad[i],s.rm[i]);
         if(!fa[i]) break;
         D=dis(x,fa[i]);
         if(D<=mad[fa[i]]) ans-=s.query(D,mad[fa[i]],,mad[fa[i]],s.rf[i]);
     }
     return ans;
 }

 int main()
 {
     scanf("%d%d",&n,&m);
     int i,j,x,y,w,ans=;
     for(i=;i<n;i++) x=gint(), y=gint(), e.ae(x,y), e.ae(y,x);
     tr::init();
     ms[]=tsz=n; G=; gra(,-); gra(G,-);
     main_dfs(G); char str[];
     for(i=;i<=m;i++)
     {
         scanf("%s",str);
         if(str[]=='M'){
             x=gint(); y=gint(); w=gint();
             modify(x,y,w);
         }else{
             x=gint();
             ans=query(x);
             printf("%d\n",ans);
         }
     }
     return ;
 }

震波那道题和这道题非常像，只不过是点的修改和子树的查询

但由于我一直被卡常，没脸放代码了qwq