题目链接：https://www.luogu.com.cn/problem/P3833
题目大意：
模板改一改就行了。
#include <bits/stdc++.h>
#define LL long long
#define RLL register int
using namespace std;
template<typename T> inline void read(T &x){
x=0;T w=1,ch=getchar();
while(!isdigit(ch)&&ch!='-')ch=getchar();
if(ch=='-')w=-1,ch=getchar();
while(isdigit(ch))x=(x<<3)+(x<<1)+(ch^'0'),ch=getchar();
x=x*w;
}
#define mid ((l+r)>>1)
#define lson rt<<1,l,mid
#define rson rt<<1|1,mid+1,r
#define len (r-l+1)
const LL maxn=500000+10;
LL n,m;
//见题意
LL tot,head[maxn],nex[maxn],to[maxn],w[maxn],wt[maxn];
//链式前向星数组，w[]、wt[]初始点权数组
LL a[maxn<<2],laz[maxn<<2];
//线段树数组、lazy操作
LL son[maxn],id[maxn],fa[maxn],cnt,dep[maxn],siz[maxn],top[maxn];
//son[]重儿子编号,id[]新编号,fa[]父亲节点,cnt dfs_clock/dfs序,dep[]深度,siz[]子树大小,top[]当前链顶端节点
LL res=0;
//查询答案
inline void add(LL x,LL y){//链式前向星加边
to[++tot]=y;
nex[tot]=head[x];
head[x]=tot;
}
//-------------------------------------- 以下为线段树
inline void pushdown(LL rt,LL lenn){
laz[rt<<1]+=laz[rt];
laz[rt<<1|1]+=laz[rt];
a[rt<<1]+=laz[rt]*(lenn-(lenn>>1));
a[rt<<1|1]+=laz[rt]*(lenn>>1);
laz[rt]=0;
}
inline void build(LL rt,LL l,LL r){
if(l==r){
a[rt]=wt[l];
return;
}
build(lson);
build(rson);
a[rt]=(a[rt<<1]+a[rt<<1|1]);
}
inline void query(LL rt,LL l,LL r,LL L,LL R){
if(L<=l&&r<=R){res+=a[rt];return;}
else{
if(laz[rt])pushdown(rt,len);
if(L<=mid)query(lson,L,R);
if(R>mid)query(rson,L,R);
}
}
inline void update(LL rt,LL l,LL r,LL L,LL R,LL k){
if(L<=l&&r<=R){
laz[rt]+=k;
a[rt]+=k*len;
}
else{
if(laz[rt])pushdown(rt,len);
if(L<=mid)update(lson,L,R,k);
if(R>mid)update(rson,L,R,k);
a[rt]=(a[rt<<1]+a[rt<<1|1]);
}
}
//---------------------------------以上为线段树
//当我们要处理任意两点间路径时：
//设所在链顶端的深度更深的那个点为x点
//
//ans加上x点到x所在链顶端 这一段区间的点权和
//把x跳到x所在链顶端的那个点的上面一个点
//不停执行这两个步骤，直到两个点处于一条链上，这时再加上此时两个点的区间和即可
//这时我们注意到，我们所要处理的所有区间均为连续编号(新编号)，于是想到线段树，用线段树处理连续编号区间和
//每次查询时间复杂度为O(logn)^2
inline void updRange(LL x,LL y,LL k){//同上
while(top[x]!=top[y]){
if(dep[top[x]]<dep[top[y]])swap(x,y);
update(1,1,n,id[top[x]],id[x],k);
x=fa[top[x]];
}
if(dep[x]>dep[y])swap(x,y);
update(1,1,n,id[x],id[y],k);
}
//处理一点及其子树的点权和：
//想到记录了每个非叶子节点的子树大小(含它自己)，并且每个子树的新编号都是连续的
//于是直接线段树区间查询即可
//时间复杂度为O(logn)
inline LL qRange(LL x,LL y){
LL ans=0;
while(top[x]!=top[y]){//当两个点不在同一条链上
if(dep[top[x]]<dep[top[y]])swap(x,y);//把x点改为所在链顶端的深度更深的那个点
res=0;
query(1,1,n,id[top[x]],id[x]);//ans加上x点到x所在链顶端 这一段区间的点权和
ans+=res;
x=fa[top[x]];//把x跳到x所在链顶端的那个点的上面一个点
}
//直到两个点处于一条链上
if(dep[x]>dep[y])swap(x,y);//把x点深度更深的那个点
res=0;
query(1,1,n,id[x],id[y]);//这时再加上此时两个点的区间和即可
ans+=res;
return ans;
}
//当然，区间修改就和区间查询一样的啦~~
inline void updSon(LL x,LL k){//同上
update(1,1,n,id[x],id[x]+siz[x]-1,k);
}
inline LL qSon(LL x){
res=0;
query(1,1,n,id[x],id[x]+siz[x]-1);//子树区间右端点为id[x]+siz[x]-1
return res;
}
inline void dfs1(LL x,LL f,LL deep){//x当前节点，f父亲，deep深度
dep[x]=deep;//标记每个点的深度
fa[x]=f;//标记每个点的父亲
siz[x]=1;//标记每个非叶子节点的子树大小
LL maxson=-1;//记录重儿子的儿子数
for(RLL i=head[x];i;i=nex[i]){
LL y=to[i];
if(y==f)continue;//若为父亲则continue
dfs1(y,x,deep+1);//dfs其儿子
siz[x]+=siz[y];//把它的儿子数加到它身上
if(siz[y]>maxson)son[x]=y,maxson=siz[y];//标记每个非叶子节点的重儿子编号
}
}
inline void dfs2(LL x,LL topf){//x当前节点，topf当前链的最顶端的节点
id[x]=++cnt;//标记每个点的新编号
wt[cnt]=w[x];//把每个点的初始值赋到新编号上来
top[x]=topf;//这个点所在链的顶端
if(!son[x])return;//如果没有儿子则返回
dfs2(son[x],topf);//按先处理重儿子，再处理轻儿子的顺序递归处理
for(RLL i=head[x];i;i=nex[i]){
LL y=to[i];
if(y==fa[x]||y==son[x])continue;
dfs2(y,y);//对于每一个轻儿子都有一条从它自己开始的链
}
}
int main(){
scanf("%lld", &n);
for(RLL i=1;i<n;i++){
LL a,b;
scanf("%lld%lld", &a, &b);
add(a+1,b+1);add(b+1,a+1);
}
dfs1(1,0,1);
dfs2(1,1);
build(1,1,n);
scanf("%lld", &m);
while(m--){
char k;
LL x,y,z;
scanf("%s", &k);
if(k=='A'){
scanf("%lld%lld%lld", &x, &y, &z);
updRange(x+1,y+1,z);
}
else{
scanf("%lld", &x);
printf("%lld\n",qSon(x+1));
}
}
}
来源：CSDN
作者：H_ang
链接：https://blog.csdn.net/qq_21433411/article/details/103524149