前置技能：
LCA
线段树/树状数组
dfs序
树上差分（有些用到，比如求每个LCA落在几条路径上）洛谷日报--差分
树形DP（有些用到）
一.原理
核心：将无规则的树形结构变成有规律的序列，再用数据结构（线段树，树状数组等）高效维护。
如以下功能：
- update（赋值或四则运算）、query任意两点间路径上的点权和
- update、query一点及其子树的点权和
- 没有改变树的形态（加边变形态的化话，用LCT）
复杂度：O(
)
二.细节
除特别说明，基本默认根结点为1
①第一遍dfs，只比求lca多求个size数组（记录结点儿子总数）和son数组（记录重儿子）
②第二遍dfs，建立链和树的下标索引关系（类似lca欧拉序），以及每条链的领头人（top）
优先dfs当前结点的重链，保证其连续，重链top是deep最小的（最先dfs的），轻链top是自己
③区间更新、求和
类似倍增求lca，先处理deep大的，deep小的不动，处理完往上（fa）跳，while直到同一条链（top相同），再处理一次。
④子树更新、求和
见模板①
三.代码
1.更新点权
①模板题 P3384
注意取模
// luogu-judger-enable-o2
// luogu-judger-enable-o2
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000+10;
int w[maxn];
int N, Q,R;
int mod;
struct
{
int to,next;
}e[maxn<<1];
int head[maxn],edgeNum;
void add(int u,int v)
{
e[edgeNum].next = head[u];
e[edgeNum].to = v;
head[u] = edgeNum++;
}
/*-------------------------树剖------------------------------*/
int deep[maxn],fa[maxn],siz[maxn],son[maxn];
void dfs1(int u,int pre,int d)
{
deep[u] = d;
fa[u] = pre;
siz[u] = 1;
son[u] = 0;
for(int i=head[u];~i;i=e[i].next)
{
int v = e[i].to;
if(v!=pre)
{
dfs1(v,u,d+1);
siz[u] += siz[v];
if(siz[v]>siz[son[u]])
son[u] = v;
}
}
}
int top[maxn],id[maxn],rk[maxn],cnt;
void dfs2(int u,int t)
{
top[u] = t;
id[u] = ++cnt;
rk[cnt] = u;
if(!son[u]) return;
dfs2(son[u],t);
for(int i=head[u];~i;i=e[i].next)
{
int v = e[i].to;
if(v!=son[u]&&v!=fa[u])
dfs2(v,v);
}
}
/*-------------------------树剖------------------------------*/
/*-------------------------线段树------------------------------*/
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
int sum[maxn<<2],lazy[maxn<<2];
void pushup(int rt)
{
sum[rt] = (sum[rt<<1] + sum[rt<<1|1])%mod;
}
void pushdown(int rt,int l,int r)
{
if(lazy[rt])
{
lazy[rt<<1] = (lazy[rt<<1] + lazy[rt])%mod;
lazy[rt<<1|1] = (lazy[rt<<1|1] + lazy[rt])%mod;
sum[rt<<1] += (lazy[rt] * l)%mod;
sum[rt<<1|1] += (lazy[rt] * r)%mod;
lazy[rt] = 0;
}
}
void change(int val,int q,int l,int r,int rt)//单点更新
{
if(l==r)
{
sum[rt] = val%mod;
return ;
}
int m = l + r >> 1;
if(q<=m)
change(val,q,lson);
else
change(val,q,rson);
pushup(rt);
}
void update(int L,int R,int val,int l,int r,int rt)
{
if(L<=l&&r<=R)
{
sum[rt] = (sum[rt] + (val) * ((r-l+1)))%mod;
lazy[rt] = lazy[rt]+val;
return ;
}
int m = l + r >> 1;
pushdown(rt,m-l+1,r-m);
if(L<=m)
update(L,R,val,lson);
if(R>m)
update(L,R,val,rson);
pushup(rt);
}
int query(int L,int R,int l,int r,int rt)
{
if(L<=l&&r<=R)
return sum[rt]%mod;
int m = l + r >> 1,ans = 0;
pushdown(rt,m-l+1,r-m);
if(L<=m)
ans = (ans + query(L,R,lson))%mod;
if(R>m)
ans = (ans + query(L,R,rson))%mod;
return ans;
}
/*-------------------------线段树------------------------------*/
/*-----------------------树剖加线段树--------------------------*/
void update(int x,int y,int z)
{
while(top[x]!=top[y])
{
if(deep[top[x]]<deep[top[y]])
swap(x,y);
update(id[top[x]],id[x],z,1,cnt,1);
x = fa[top[x]];
}
if(deep[x]>deep[y])
swap(x,y);
update(id[x],id[y],z,1,cnt,1);
}
int query(int x,int y)
{
int ans = 0;
while(top[x] != top[y])
{
if(deep[top[x]] < deep[top[y]])
swap(x,y);
ans = (ans + query(id[top[x]],id[x],1,cnt,1));//这里下标从1开始
x = fa[top[x]];
}
if(deep[x]>deep[y])
swap(x,y);
ans = (ans + query(id[x],id[y],1,cnt,1))%mod;
return ans;
}
int qSon(int x){
int res=0;
res=(res+query(id[x],id[x]+siz[x]-1,1,N,1))%mod;//子树区间右端点为id[x]+siz[x]-1
return res;
}
void updSon(int x,int k){
update(id[x],id[x]+siz[x]-1,k,1,N,1);
}
/*-----------------------树剖加线段树--------------------------*/
void init()
{
memset(head,-1,4*N+4);
cnt = edgeNum = 0;
}
int u, v, p, x,y,z;
int main()
{
scanf("%d%d%d%d",&N,&Q,&R,&mod);
init();
for(int i=1;i<=N;i++)scanf("%d",&w[i]);
for(int i=1;i<N;++i)
{
// w[i] = 0;
scanf("%d%d",&u,&v);
add(u,v);
add(v,u);
}
dfs1(R,0,1);
dfs2(R,R);
// build(1,cnt,1);
for(int i=1;i<=N;i++){
// int tmp=deep[edge[i].u] > deep[edge[i].v] ? edge[i].u : edge[i].v;
change(w[i]%mod,id[i],1,N,1);
}
for(int i=1;i<=Q;i++)
{
scanf("%d%d%",&p,&x);
if(p==1){
scanf("%d%d",&y,&z);
update(x,y,z%mod);
}
else if(p==2){
scanf("%d",&y);
printf("%d\n",query(x,y)%mod);
}
else if(p==3){
scanf("%d",&z);
updSon(x,z%mod);
}
else{
printf("%d\n",qSon(x)%mod);
}
}
return 0;
}
②P2590 树的统计
单点更新区间查询
注意初始化，最值可能为负数
#include <bits/stdc++.h>
using namespace std;
const int maxn = 30000+10;
#define inf 1000000000
int w[maxn];
int N, Q;
struct
{
int to,next;
}e[maxn<<2];
int head[maxn],edgeNum;
int ans[maxn];
void add(int u,int v)
{
e[edgeNum].next = head[u];
e[edgeNum].to = v;
head[u] = edgeNum++;
}
/*-------------------------树剖------------------------------*/
int deep[maxn],fa[maxn],siz[maxn],son[maxn];
void dfs1(int u,int pre,int d)
{
deep[u] = d;
fa[u] = pre;
siz[u] = 1;
son[u] = 0;
for(int i=head[u];~i;i=e[i].next)
{
int v = e[i].to;
if(v!=pre)
{
dfs1(v,u,d+1);
siz[u] += siz[v];
if(siz[v]>siz[son[u]])
son[u] = v;
}
}
}
int top[maxn],id[maxn],rk[maxn],cnt;
void dfs2(int u,int t)
{
top[u] = t;
id[u] = ++cnt;
rk[cnt] = u;
if(!son[u]) return;
dfs2(son[u],t);
for(int i=head[u];~i;i=e[i].next)
{
int v = e[i].to;
if(v!=son[u]&&v!=fa[u])
dfs2(v,v);
}
}
/*-------------------------树剖------------------------------*/
/*-------------------------线段树------------------------------*/
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
int sum[maxn<<2],maxv[maxn<<2],lazy[maxn<<2];
void pushup(int rt)
{
sum[rt] = (sum[rt<<1] + sum[rt<<1|1]);
maxv[rt] =max(maxv[rt<<1],maxv[rt<<1|1]);
}
void change(int val,int q,int l,int r,int rt)//单点更新
{
if(l==r)
{
sum[rt] = val;
maxv[rt]=val;
return ;
}
int m = l + r >> 1;
if(q<=m)
change(val,q,lson);
else
change(val,q,rson);
pushup(rt);
}
int query(int L,int R,int l,int r,int rt)
{
if(L<=l&&r<=R)
return sum[rt];
int m = l + r >> 1,ans = 0;
if(L<=m)
ans = (ans + query(L,R,lson));
if(R>m)
ans = (ans + query(L,R,rson));
return ans;
}
int querymax(int L,int R,int l,int r,int rt){
if (L<=l&&r<=R)return maxv[rt];
int m=(l+r)>>1,ans=-inf;//注意负数①
if (L<=m)ans=max(ans,querymax(L,R,lson));
if (R>m)ans=max(ans,querymax(L,R,rson));
//pushup(rt);
return ans;
}
/*-------------------------线段树------------------------------*/
/*-----------------------树剖加线段树--------------------------*/
int query(int x,int y)
{
int ans = 0;
while(top[x] != top[y])
{
if(deep[top[x]] < deep[top[y]])
swap(x,y);
ans = (ans + query(id[top[x]],id[x],1,cnt,1));//这里下标从1开始
x = fa[top[x]];
}
if(deep[x]>deep[y])
swap(x,y);
ans = (ans + query(id[x],id[y],1,cnt,1));
return ans;
}
int querymax(int x,int y)
{
int ans =-inf;//注意负数②
while(top[x] != top[y])
{
if(deep[top[x]] < deep[top[y]])
swap(x,y);
ans = max(ans ,querymax(id[top[x]],id[x],1,cnt,1));//这里下标从1开始
x = fa[top[x]];
}
if(deep[x]>deep[y])
swap(x,y);
ans = max(ans ,querymax(id[x],id[y],1,cnt,1));
return ans;
}
/*-----------------------树剖加线段树--------------------------*/
void init()
{
memset(head,-1,4*N+4);
cnt = edgeNum = 0;
}
int u, v, l, r,z;
int main()
{
scanf("%d",&N);
init();
for(int i=1;i<N;++i)
{
//w[i] = 0;
scanf("%d%d",&u,&v);
add(u,v);
add(v,u);
}
dfs1(1,0,1);
dfs2(1,1);
for(int i=1;i<=N;i++)scanf("%d",&w[i]),change(w[i],id[i],1,N,1);
scanf("%d",&Q);
// build(1,cnt,1);
while(Q--)
{
char p[10];
scanf("%s %d%d",p,&r,&z);
if(p[1]=='H')change(z,id[r],1,N,1) ;
else if(p[1]=='S')printf("%d\n",query(r,z));
else if(p[1]=='M')printf("%d\n",querymax(r,z));
}
return 0;
}
③LightOJ 1348
#include <stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
const int maxn = 30010+10;
#define inf 1000000005
int w[maxn];
int N, Q;
struct
{
int to,next,w;
}e[maxn<<2];
int head[maxn<<1],edgeNum;
struct
{
int u,v;
}edge[maxn<<1];
void add(int u,int v)
{
e[edgeNum].next = head[u];
e[edgeNum].to = v;
// e[edgeNum].w=w;
head[u] = edgeNum++;
}
/*-------------------------树剖------------------------------*/
int deep[maxn],fa[maxn],siz[maxn],son[maxn];
void dfs1(int u,int pre,int d)
{
deep[u] = d;
fa[u] = pre;
siz[u] = 1;
son[u] = 0;
for(int i=head[u];~i;i=e[i].next)
{
int v = e[i].to;
if(v!=pre)
{
dfs1(v,u,d+1);
siz[u] += siz[v];
if(siz[v]>siz[son[u]])
son[u] = v;
}
}
}
int top[maxn],id[maxn],rk[maxn],cnt;
void dfs2(int u,int t)
{
top[u] = t;
id[u] = ++cnt;
rk[cnt] = u;
if(!son[u]) return;
dfs2(son[u],t);
for(int i=head[u];~i;i=e[i].next)
{
int v = e[i].to;
if(v!=son[u]&&v!=fa[u])
dfs2(v,v);
}
}
/*-------------------------树剖------------------------------*/
/*-------------------------线段树------------------------------*/
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
int sum[maxn<<2],maxv[maxn<<2],lazy[maxn<<2];
void pushup(int rt)
{
sum[rt] = (sum[rt<<1] + sum[rt<<1|1]);
maxv[rt] =max(maxv[rt<<1],maxv[rt<<1|1]);
}
void change(int val,int q,int l,int r,int rt)//单点更新
{
if(l==r)
{
sum[rt] = val;
maxv[rt]=val;
return ;
}
int m = l + r >> 1;
if(q<=m)
change(val,q,lson);
else
change(val,q,rson);
pushup(rt);
}
int query(int L,int R,int l,int r,int rt)
{
if(L<=l&&r<=R)
return sum[rt];
int m = l + r >> 1,ans = 0;
if(L<=m)
ans = (ans + query(L,R,lson));
if(R>m)
ans = (ans + query(L,R,rson));
return ans;
}
int querymax(int L,int R,int l,int r,int rt){
if (L<=l&&r<=R)return maxv[rt];
int m=(l+r)>>1,ans=-inf;//注意负数①
if (L<=m)ans=max(ans,querymax(L,R,lson));
if (R>m)ans=max(ans,querymax(L,R,rson));
//pushup(rt);
return ans;
}
/*-------------------------线段树------------------------------*/
/*-----------------------树剖加线段树--------------------------*/
int query(int x,int y)
{
int ans = 0;
while(top[x] != top[y])
{
if(deep[top[x]] < deep[top[y]])
swap(x,y);
ans = (ans + query(id[top[x]],id[x],1,cnt,1));//这里下标从1开始
x = fa[top[x]];
}
if(deep[x]>deep[y])
swap(x,y);
ans = (ans + query(id[x],id[y],1,cnt,1));
return ans;
}
int querymax(int x,int y)
{
int ans =-inf;//注意负数②
while(top[x] != top[y])
{
if(deep[top[x]] < deep[top[y]])
swap(x,y);
ans = max(ans ,querymax(id[top[x]],id[x],1,cnt,1));
x = fa[top[x]];
}
if(deep[x]>deep[y])
swap(x,y);
ans = max(ans ,querymax(id[x],id[y],1,cnt,1));//跳过LCA（深度小的），所以+1
return ans;
}
/*-----------------------树剖加线段树--------------------------*/
void init()
{
memset(head,-1,4*N+4);
cnt = edgeNum = 0;
}
int u, v, o,z,cur;
int main()
{
int T;
scanf("%d",&T);
for(int i=1;i<=T;i++){
printf("Case %d:\n",i);
scanf("%d",&N);
memset(head,0,sizeof(head));
init();
for(int i=1;i<=N;i++)scanf("%d",&w[i]);
for(int i=1;i<N;++i)
{
//w[i] = 0;
scanf("%d%d",&u,&v);
u++,v++;
// edge[i].u=u,edge[i].v=v;//真正的边数
add(u,v);//边数*2
add(v,u);
}
dfs1(1,0,1);
dfs2(1,1);
for(int i=1;i<=N;i++){
// int tmp=deep[edge[i].u] > deep[edge[i].v] ? edge[i].u : edge[i].v;
change(w[i],id[i],1,N,1);
}
scanf("%d",&Q);
// build(1,cnt,1);
while(Q--)
{
int p;
scanf("%d",&p);
//scanf("%d%d",&r,&z);
if(p==1){
scanf("%d%d",&o,&z);
// o=deep[edge[o].u] > deep[edge[o].v] ? edge[o].u : edge[o].v;
change(z,id[++o],1,N,1) ;
}
else if(p==0){
scanf("%d%d",&o,&z);
printf("%d\n",query(++o,++z));
}
}
}
return 0;
}
④BZOJ 4034 树上操作
单点加子树和
long long开多会TLE，memset似乎只能int
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 100000+10;
ll w[maxn];//权值和结点以及query的sum才开long long
int N, Q,R;
struct
{
int to,next;
}e[maxn<<1];
int head[maxn],edgeNum;
void add(int u,int v)
{
e[edgeNum].next = head[u];
e[edgeNum].to = v;
head[u] = edgeNum++;
}
/*-------------------------树剖------------------------------*/
int deep[maxn],fa[maxn],siz[maxn],son[maxn];
void dfs1(int u,int pre,int d)
{
deep[u] = d;
fa[u] = pre;
siz[u] = 1;
son[u] = 0;
for(int i=head[u];~i;i=e[i].next)
{
int v = e[i].to;
if(v!=pre)
{
dfs1(v,u,d+1);
siz[u] += siz[v];
if(siz[v]>siz[son[u]])
son[u] = v;
}
}
}
int top[maxn],id[maxn],rk[maxn],cnt;
void dfs2(int u,int t)
{
top[u] = t;
id[u] = ++cnt;
rk[cnt] = u;
if(!son[u]) return;
dfs2(son[u],t);
for(int i=head[u];~i;i=e[i].next)
{
int v = e[i].to;
if(v!=son[u]&&v!=fa[u])
dfs2(v,v);
}
}
/*-------------------------树剖------------------------------*/
/*-------------------------线段树------------------------------*/
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
ll sum[maxn<<2],lazy[maxn<<2];
void pushup(int rt)
{
sum[rt] = (sum[rt<<1] + sum[rt<<1|1]);
}
void pushdown(int rt,int l,int r)
{
if(lazy[rt])
{
lazy[rt<<1] = (lazy[rt<<1] + lazy[rt]);
lazy[rt<<1|1] = (lazy[rt<<1|1] + lazy[rt]);
sum[rt<<1] += (lazy[rt] * l);
sum[rt<<1|1] += (lazy[rt] * r);
lazy[rt] = 0;
}
}
void change(ll val,int q,int l,int r,int rt)//单点更新
{
if(l==r)
{
sum[rt] = val;
return ;
}
int m = l + r >> 1;
if(q<=m)
change(val,q,lson);
else
change(val,q,rson);
pushup(rt);
}
void change1(ll val,ll q,ll l,ll r,ll rt)//单点更新
{
if(l==r)
{
sum[rt] += val;
return ;
}
ll m = l + r >> 1;
if(q<=m)
change(val,q,lson);
else
change(val,q,rson);
pushup(rt);
}
void update(int L,int R,ll val,int l,int r,int rt)
{
if(L<=l&&r<=R)
{
sum[rt] = (sum[rt] + (val) * ((r-l+1)));
lazy[rt] = lazy[rt]+val;
return ;
}
int m = l + r >> 1;
pushdown(rt,m-l+1,r-m);
if(L<=m)
update(L,R,val,lson);
if(R>m)
update(L,R,val,rson);
pushup(rt);
}
ll query(int L,int R,int l,int r,int rt)
{
if(L<=l&&r<=R)
return sum[rt];
int m = l + r >> 1;
ll ans = 0;
pushdown(rt,m-l+1,r-m);
if(L<=m)
ans = (ans + query(L,R,lson));
if(R>m)
ans = (ans + query(L,R,rson));
return ans;
}
/*-------------------------线段树------------------------------*/
/*-----------------------树剖加线段树--------------------------*/
void update(int x,int y,int z)
{
while(top[x]!=top[y])
{
if(deep[top[x]]<deep[top[y]])
swap(x,y);
update(id[top[x]],id[x],z,1,cnt,1);
x = fa[top[x]];
}
if(deep[x]>deep[y])
swap(x,y);
update(id[x],id[y],z,1,cnt,1);
}
ll query(int x,int y)
{
ll ans = 0;
while(top[x] != top[y])
{
if(deep[top[x]] < deep[top[y]])
swap(x,y);
ans = (ans + query(id[top[x]],id[x],1,cnt,1));//这里下标从1开始
x = fa[top[x]];
}
if(deep[x]>deep[y])
swap(x,y);
ans = (ans + query(id[x],id[y],1,cnt,1));
return ans;
}
ll qSon(ll x){
ll res=0;
res=(res+query(id[x],id[x]+siz[x]-1,1,N,1));//子树区间右端点为id[x]+siz[x]-1
return res;
}
void updSon(int x,ll k){
update(id[x],id[x]+siz[x]-1,k,1,N,1);
}
/*-----------------------树剖加线段树--------------------------*/
void init()
{
memset(head,-1,4*N+4);//容易出错
cnt = edgeNum = 0;
}
int u, v, p, x,y;
ll z;
int main()
{
scanf("%d%d",&N,&Q);
init();
for(ll i=1;i<=N;i++)scanf("%lld",&w[i]);
for(ll i=1;i<N;++i)
{
// w[i] = 0;
scanf("%d%d",&u,&v);
add(u,v);
add(v,u);
}
dfs1(1,0,1);
dfs2(1,1);
// build(1,cnt,1);
for(ll i=1;i<=N;i++){
// int tmp=deep[edge[i].u] > deep[edge[i].v] ? edge[i].u : edge[i].v;
change(w[i],id[i],1,N,1);
}
for(ll i=1;i<=Q;i++)
{
scanf("%d%d",&p,&x);
if(p==1){
scanf("%lld",&z);
// change1(z,id[x],1,N,1);
update(x,x,z);
}
else if(p==3){
printf("%lld\n",query(x,1));
}
else if(p==2){
scanf("%lld",&z);
updSon(x,z);
}
}
return 0;
}
⑤HDU 3966 Aragorn's Story
多组输入线段树一定要build！！！主要是清空未下放的lazy值（可能只更新不查询，lazy就不会清空）
其他题没用build能过，是因为没涉及区间更新（lazy）
#include <stdio.h>
#include<string.h>
#include<algorithm>
#include<iostream>
using namespace std;
const int maxn = 50010+10;
typedef long long ll;
int w[maxn];
int N, Q,M;
struct
{
int to,next,w;
}e[maxn<<2];
int head[maxn<<1],edgeNum;
struct
{
int u,v;
}edge[maxn<<1];
void add(int u,int v)
{
e[edgeNum].next = head[u];
e[edgeNum].to = v;
// e[edgeNum].w=w;
head[u] = edgeNum++;
}
/*-------------------------树剖------------------------------*/
int deep[maxn],fa[maxn],siz[maxn],son[maxn];
void dfs1(int u,int pre,int d)
{
deep[u] = d;
fa[u] = pre;
siz[u] = 1;
son[u] = 0;
for(int i=head[u];~i;i=e[i].next)
{
int v = e[i].to;
if(v!=pre)
{
dfs1(v,u,d+1);
siz[u] += siz[v];
if(siz[v]>siz[son[u]])
son[u] = v;
}
}
}
int top[maxn],id[maxn],rk[maxn],cnt;
void dfs2(int u,int t)
{
top[u] = t;
id[u] = ++cnt;
rk[cnt] = u;
if(!son[u]) return;
dfs2(son[u],t);
for(int i=head[u];~i;i=e[i].next)
{
int v = e[i].to;
if(v!=son[u]&&v!=fa[u])
dfs2(v,v);
}
}
/*-------------------------树剖------------------------------*/
/*-------------------------线段树------------------------------*/
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
ll sum[maxn<<2],lazy[maxn<<2];
void pushup(int rt)
{
sum[rt] = (sum[rt<<1] + sum[rt<<1|1]);
}
void pushdown(int rt,int l,int r)
{
if(lazy[rt])
{
lazy[rt<<1] = (lazy[rt<<1] + lazy[rt]);
lazy[rt<<1|1] = (lazy[rt<<1|1] + lazy[rt]);
sum[rt<<1] += (lazy[rt] * l);
sum[rt<<1|1] += (lazy[rt] * r);
lazy[rt] = 0;
}
}
void build(int l,int r,int rt)//清空
{
lazy[rt]=0;
sum[rt]=0;
if(l==r) return;
int m=(l+r)>>1;
build(lson);
build(rson);
pushup(rt);
}
void change(int val,int q,int l,int r,int rt)//单点更新
{
if(l==r)
{
sum[rt] = val;
return ;
}
int m = l + r >> 1;
if(q<=m)
change(val,q,lson);
else
change(val,q,rson);
pushup(rt);
}
void update(int L,int R,int val,int l,int r,int rt)
{
if(L<=l&&r<=R)
{
sum[rt] = (sum[rt] + (val) * ((r-l+1)));
lazy[rt] = lazy[rt]+val;
return ;
}
int m = l + r >> 1;
pushdown(rt,m-l+1,r-m);
if(L<=m)
update(L,R,val,lson);
if(R>m)
update(L,R,val,rson);
pushup(rt);
}
ll query(int L,int R,int l,int r,int rt)
{
if(L<=l&&r<=R)
return sum[rt];
int m = l + r >> 1;
ll ans = 0;
pushdown(rt,m-l+1,r-m);
if(L<=m)
ans = (ans + query(L,R,lson));
if(R>m)
ans = (ans + query(L,R,rson));
return ans;
}
/*-------------------------线段树------------------------------*/
/*-----------------------树剖加线段树--------------------------*/
void update(int x,int y,int z)
{
while(top[x]!=top[y])
{
if(deep[top[x]]<deep[top[y]])
swap(x,y);
update(id[top[x]],id[x],z,1,cnt,1);
x = fa[top[x]];
}
if(deep[x]>deep[y])
swap(x,y);
update(id[x],id[y],z,1,cnt,1);
}
ll query(int x,int y)
{
ll ans = 0;
while(top[x] != top[y])
{
if(deep[top[x]] < deep[top[y]])
swap(x,y);
ans = (ans + query(id[top[x]],id[x],1,cnt,1));//这里下标从1开始
x = fa[top[x]];
}
if(deep[x]>deep[y])
swap(x,y);
ans = (ans + query(id[x],id[y],1,cnt,1));
return ans;
}
/*-----------------------树剖加线段树--------------------------*/
void init()
{
memset(head,-1,4*N+4);
memset(siz,0,sizeof(siz));
memset(son,0,sizeof(son));
//memset(fa,0,sizeof(fa));
//memset(deep,0,sizeof(deep));
cnt = edgeNum = 0;
}
int u, v, x,y,z;
int main()
{
while(~scanf("%d %d %d",&N,&M,&Q)){
// memset(head,-1,sizeof(head));
init();
for(int i=1;i<=N;i++)scanf("%d",&w[i]);
for(int i=1;i<=M;++i)
{
scanf("%d %d",&u,&v);
// edge[i].u=u,edge[i].v=v;//真正的边数
add(u,v);//边数*2
add(v,u);
}
dfs1(1,0,1);
dfs2(1,1);
build(1,cnt,1) ;//清空
for(int i=1;i<=N;i++){
// int tmp=deep[edge[i].u] > deep[edge[i].v] ? edge[i].u : edge[i].v;
change(w[i],id[i],1,N,1);
}
while(Q--)
{
char p;
scanf("%s",&p);//不能%c
if(p=='I'){
scanf("%d%d%d",&x,&y,&z);
// o=deep[edge[o].u] > deep[edge[o].v] ? edge[o].u : edge[o].v;
//change(z,id[++o],1,N,1) ;
update(x,y,z);
}
else if(p=='D'){
scanf("%d%d%d",&x,&y,&z);
update(x,y,-z);
}
else if(p=='Q'){
scanf("%d",&x);
printf("%lld\n",query(x,x));
}
}
}
return 0;
}
2.更新边权
①SPOJ QUERY ON A TREE
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10000+10;
#define inf 1000000000
int w[maxn];
int N, Q;
struct
{
int to,next,w;
}e[maxn<<2];
int head[maxn<<1],edgeNum;
struct
{
int u,v;
}edge[maxn<<1];
void add(int u,int v,int w)
{
e[edgeNum].next = head[u];
e[edgeNum].to = v;
e[edgeNum].w=w;
head[u] = edgeNum++;//从0开始
}
/*-------------------------树剖------------------------------*/
int deep[maxn],fa[maxn],siz[maxn],son[maxn];
void dfs1(int u,int pre,int d)
{
deep[u] = d;
fa[u] = pre;
siz[u] = 1;
son[u] = 0;
for(int i=head[u];~i;i=e[i].next)
{
int v = e[i].to;
if(v!=pre)
{
dfs1(v,u,d+1);
siz[u] += siz[v];
if(siz[v]>siz[son[u]])
son[u] = v;
}
}
}
int top[maxn],id[maxn],rk[maxn],cnt;
void dfs2(int u,int t)
{
top[u] = t;
id[u] = ++cnt;
rk[cnt] = u;
if(!son[u]) return;
dfs2(son[u],t);
for(int i=head[u];~i;i=e[i].next)
{
int v = e[i].to;
if(v!=son[u]&&v!=fa[u])
dfs2(v,v);
}
}
/*-------------------------树剖------------------------------*/
/*-------------------------线段树------------------------------*/
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
int sum[maxn<<2],maxv[maxn<<2],lazy[maxn<<2];
void pushup(int rt)
{
sum[rt] = (sum[rt<<1] + sum[rt<<1|1]);
maxv[rt] =max(maxv[rt<<1],maxv[rt<<1|1]);
}
void change(int val,int q,int l,int r,int rt)//单点更新
{
if(l==r)
{
sum[rt] = val;
maxv[rt]=val;
return ;
}
int m = l + r >> 1;
if(q<=m)
change(val,q,lson);
else
change(val,q,rson);
pushup(rt);
}
int query(int L,int R,int l,int r,int rt)
{
if(L<=l&&r<=R)
return sum[rt];
int m = l + r >> 1,ans = 0;
if(L<=m)
ans = (ans + query(L,R,lson));
if(R>m)
ans = (ans + query(L,R,rson));
return ans;
}
int querymax(int L,int R,int l,int r,int rt){
if (L<=l&&r<=R)return maxv[rt];
int m=(l+r)>>1,ans=-inf;//注意负数①
if (L<=m)ans=max(ans,querymax(L,R,lson));
if (R>m)ans=max(ans,querymax(L,R,rson));
//pushup(rt);
return ans;
}
/*-------------------------线段树------------------------------*/
/*-----------------------树剖加线段树--------------------------*/
int query(int x,int y)
{
int ans = 0;
while(top[x] != top[y])
{
if(deep[top[x]] < deep[top[y]])
swap(x,y);
ans = (ans + query(id[top[x]],id[x],1,cnt,1));//这里下标从1开始
x = fa[top[x]];
}
if(deep[x]>deep[y])
swap(x,y);
ans = (ans + query(id[x],id[y],1,cnt,1));
return ans;
}
int querymax(int x,int y)
{
int ans =-inf;//注意负数②
while(top[x] != top[y])
{
if(deep[top[x]] < deep[top[y]])
swap(x,y);
ans = max(ans ,querymax(id[top[x]],id[x],1,cnt,1));
x = fa[top[x]];
}
if(deep[x]>deep[y])
swap(x,y);
ans = max(ans ,querymax(id[x]+1,id[y],1,cnt,1));//跳过LCA（深度小的），所以+1
return ans;
}
/*-----------------------树剖加线段树--------------------------*/
void init()
{
memset(head,-1,4*N+4);
cnt = edgeNum = 0;
}
int u, v, l, r,z;
int main()
{
int T;
scanf("%d",&T) ;
while(T--){
memset(head,0,sizeof(head));
scanf("%d",&N);
init();
for(int i=1;i<N;++i)
{
//w[i] = 0;
scanf("%d%d%d",&u,&v,&w[i]);
edge[i].u=u;
edge[i].v=v;//真正的边数
add(u,v,w[i]);//边数*2
add(v,u,w[i]);
}
dfs1(1,0,1);
dfs2(1,1);
for(int i=1;i<N;i++){
int tmp=deep[edge[i].u] > deep[edge[i].v] ? edge[i].u : edge[i].v;
change(w[i],id[tmp],1,N,1);
}
//scanf("%d",&Q);
// build(1,cnt,1);
while(1)
{
char p[10];
scanf("%s",p);
if(p[0]=='D')break;//这里就要break！不然会继续输入
scanf("%d%d",&r,&z);
if(p[0]=='C'){
r=deep[edge[r].u] > deep[edge[r].v] ? edge[r].u : edge[r].v;
change(z,id[r],1,N,1) ;
}
else if(p[0]=='Q')printf("%d\n",querymax(r,z));
}
}
return 0;
}
②poj2763 Housewife Wind
#include <stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
const int maxn = 100010+10;
#define inf 1000000005
int w[maxn];
int N, Q;
struct
{
int to,next,w;
}e[maxn<<2];
int head[maxn<<1],edgeNum;
struct
{
int u,v;
}edge[maxn<<1];
void add(int u,int v,int w)
{
e[edgeNum].next = head[u];
e[edgeNum].to = v;
e[edgeNum].w=w;
head[u] = edgeNum++;
}
/*-------------------------树剖------------------------------*/
int deep[maxn],fa[maxn],siz[maxn],son[maxn];
void dfs1(int u,int pre,int d)
{
deep[u] = d;
fa[u] = pre;
siz[u] = 1;
son[u] = 0;
for(int i=head[u];~i;i=e[i].next)
{
int v = e[i].to;
if(v!=pre)
{
dfs1(v,u,d+1);
siz[u] += siz[v];
if(siz[v]>siz[son[u]])
son[u] = v;
}
}
}
int top[maxn],id[maxn],rk[maxn],cnt;
void dfs2(int u,int t)
{
top[u] = t;
id[u] = ++cnt;
rk[cnt] = u;
if(!son[u]) return;
dfs2(son[u],t);
for(int i=head[u];~i;i=e[i].next)
{
int v = e[i].to;
if(v!=son[u]&&v!=fa[u])
dfs2(v,v);
}
}
/*-------------------------树剖------------------------------*/
/*-------------------------线段树------------------------------*/
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
int sum[maxn<<2],maxv[maxn<<2],lazy[maxn<<2];
void pushup(int rt)
{
sum[rt] = (sum[rt<<1] + sum[rt<<1|1]);
maxv[rt] =max(maxv[rt<<1],maxv[rt<<1|1]);
}
void change(int val,int q,int l,int r,int rt)//单点更新
{
if(l==r)
{
sum[rt] = val;
maxv[rt]=val;
return ;
}
int m = l + r >> 1;
if(q<=m)
change(val,q,lson);
else
change(val,q,rson);
pushup(rt);
}
int query(int L,int R,int l,int r,int rt)
{
if(L<=l&&r<=R)
return sum[rt];
int m = l + r >> 1,ans = 0;
if(L<=m)
ans = (ans + query(L,R,lson));
if(R>m)
ans = (ans + query(L,R,rson));
return ans;
}
int querymax(int L,int R,int l,int r,int rt){
if (L<=l&&r<=R)return maxv[rt];
int m=(l+r)>>1,ans=-inf;//注意负数①
if (L<=m)ans=max(ans,querymax(L,R,lson));
if (R>m)ans=max(ans,querymax(L,R,rson));
//pushup(rt);
return ans;
}
/*-------------------------线段树------------------------------*/
/*-----------------------树剖加线段树--------------------------*/
int query(int x,int y)
{
int ans = 0;
while(top[x] != top[y])
{
if(deep[top[x]] < deep[top[y]])
swap(x,y);
ans = (ans + query(id[top[x]],id[x],1,cnt,1));//这里下标从1开始
x = fa[top[x]];
}
if(deep[x]>deep[y])
swap(x,y);
ans = (ans + query(id[x]+1,id[y],1,cnt,1));
return ans;
}
int querymax(int x,int y)
{
int ans =-inf;//注意负数②
while(top[x] != top[y])
{
if(deep[top[x]] < deep[top[y]])
swap(x,y);
ans = max(ans ,querymax(id[top[x]],id[x],1,cnt,1));
x = fa[top[x]];
}
if(deep[x]>deep[y])
swap(x,y);
ans = max(ans ,querymax(id[x]+1,id[y],1,cnt,1));//跳过LCA（深度小的），所以+1
return ans;
}
/*-----------------------树剖加线段树--------------------------*/
void init()
{
memset(head,-1,4*N+4);
cnt = edgeNum = 0;
}
int u, v, o,z,cur;
int main()
{
while(~scanf("%d%d%d",&N,&Q,&cur)){
memset(head,0,sizeof(head));
init();
for(int i=1;i<N;++i)
{
//w[i] = 0;
scanf("%d%d%d",&u,&v,&w[i]);
edge[i].u=u;
edge[i].v=v;//真正的边数
add(u,v,w[i]);//边数*2
add(v,u,w[i]);
}
dfs1(1,0,1);
dfs2(1,1);
for(int i=1;i<N;i++){
int tmp=deep[edge[i].u] > deep[edge[i].v] ? edge[i].u : edge[i].v;
change(w[i],id[tmp],1,N,1);
}
//scanf("%d",&Q);
// build(1,cnt,1);
while(Q--)
{
int p;
scanf("%d",&p);
//scanf("%d%d",&r,&z);
if(p==1){
scanf("%d%d",&o,&z);
o=deep[edge[o].u] > deep[edge[o].v] ? edge[o].u : edge[o].v;
change(z,id[o],1,N,1) ;
}
else if(p==0){
scanf("%d",&o);
printf("%d\n",query(cur,o));
cur=o;
}
}
}
return 0;
}
③FZU2082 过路费
#include <stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
const int maxn = 50000+10;//fzu不支持bits/stdc++头文件
#define inf 1000000005
int w[maxn];
int N, Q;
struct
{
int to,next,w;
}e[maxn<<2];
int head[maxn<<1],edgeNum;
struct
{
int u,v;
}edge[maxn<<1];
void add(int u,int v,int w)
{
e[edgeNum].next = head[u];
e[edgeNum].to = v;
e[edgeNum].w=w;
head[u] = edgeNum++;
}
/*-------------------------树剖------------------------------*/
int deep[maxn],fa[maxn],siz[maxn],son[maxn];
void dfs1(int u,int pre,int d)
{
deep[u] = d;
fa[u] = pre;
siz[u] = 1;
son[u] = 0;
for(int i=head[u];~i;i=e[i].next)
{
int v = e[i].to;
if(v!=pre)
{
dfs1(v,u,d+1);
siz[u] += siz[v];
if(siz[v]>siz[son[u]])
son[u] = v;
}
}
}
int top[maxn],id[maxn],rk[maxn],cnt;
void dfs2(int u,int t)
{
top[u] = t;
id[u] = ++cnt;
rk[cnt] = u;
if(!son[u]) return;
dfs2(son[u],t);
for(int i=head[u];~i;i=e[i].next)
{
int v = e[i].to;
if(v!=son[u]&&v!=fa[u])
dfs2(v,v);
}
}
/*-------------------------树剖------------------------------*/
/*-------------------------线段树------------------------------*/
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
int sum[maxn<<2],maxv[maxn<<2],lazy[maxn<<2];
void pushup(int rt)
{
sum[rt] = (sum[rt<<1] + sum[rt<<1|1]);
maxv[rt] =max(maxv[rt<<1],maxv[rt<<1|1]);
}
void change(int val,int q,int l,int r,int rt)//单点更新
{
if(l==r)
{
sum[rt] = val;
maxv[rt]=val;
return ;
}
int m = l + r >> 1;
if(q<=m)
change(val,q,lson);
else
change(val,q,rson);
pushup(rt);
}
int query(int L,int R,int l,int r,int rt)
{
if(L<=l&&r<=R)
return sum[rt];
int m = l + r >> 1,ans = 0;
if(L<=m)
ans = (ans + query(L,R,lson));
if(R>m)
ans = (ans + query(L,R,rson));
return ans;
}
int querymax(int L,int R,int l,int r,int rt){
if (L<=l&&r<=R)return maxv[rt];
int m=(l+r)>>1,ans=-inf;//注意负数①
if (L<=m)ans=max(ans,querymax(L,R,lson));
if (R>m)ans=max(ans,querymax(L,R,rson));
//pushup(rt);
return ans;
}
/*-------------------------线段树------------------------------*/
/*-----------------------树剖加线段树--------------------------*/
int query(int x,int y)
{
int ans = 0;
while(top[x] != top[y])
{
if(deep[top[x]] < deep[top[y]])
swap(x,y);
ans = (ans + query(id[top[x]],id[x],1,cnt,1));//这里下标从1开始
x = fa[top[x]];
}
if(deep[x]>deep[y])
swap(x,y);
ans = (ans + query(id[x]+1,id[y],1,cnt,1));
return ans;
}
int querymax(int x,int y)
{
int ans =-inf;//注意负数②
while(top[x] != top[y])
{
if(deep[top[x]] < deep[top[y]])
swap(x,y);
ans = max(ans ,querymax(id[top[x]],id[x],1,cnt,1));
x = fa[top[x]];
}
if(deep[x]>deep[y])
swap(x,y);
ans = max(ans ,querymax(id[x]+1,id[y],1,cnt,1));//跳过LCA（深度小的），所以+1
return ans;
}
/*-----------------------树剖加线段树--------------------------*/
void init()
{
memset(head,-1,4*N+4);
cnt = edgeNum = 0;
}
int u, v, l, r,z;
int main()
{
while(~scanf("%d%d",&N,&Q)){
memset(head,0,sizeof(head));
init();
for(int i=1;i<N;++i)
{
//w[i] = 0;
scanf("%d%d%d",&u,&v,&w[i]);
edge[i].u=u;
edge[i].v=v;//真正的边数
add(u,v,w[i]);//边数*2
add(v,u,w[i]);
}
dfs1(1,0,1);
dfs2(1,1);
for(int i=1;i<N;i++){
int tmp=deep[edge[i].u] > deep[edge[i].v] ? edge[i].u : edge[i].v;
change(w[i],id[tmp],1,N,1);
}
//scanf("%d",&Q);
// build(1,cnt,1);
while(Q--)
{
int p;
scanf("%d",&p);
scanf("%d%d",&r,&z);
if(p==0){
r=deep[edge[r].u] > deep[edge[r].v] ? edge[r].u : edge[r].v;
change(z,id[r],1,N,1) ;
}
else if(p==1)printf("%d\n",query(r,z));
}
}
return 0;
}
3.染色（带方向）
4.转化、应用
有些题目不那么直白，给出xx操作，会另外开博客讲解
如：
gym101908L
P4211/BZOJ 3626 LCA
LCA是个很灵活的东西，此题前建议先学习树上差分
#include <bits/stdc++.h>
using namespace std;
const int maxn = 50000+10;
//int w[maxn];
int N, Q;
int mod=201314;
struct
{
int to,next;
}e[maxn<<1];
int head[maxn],edgeNum;
struct node{
int z,opt,id;
};
vector<node>v1[maxn];
int ans[maxn];
void add(int u,int v)
{
e[edgeNum].next = head[u];
e[edgeNum].to = v;
head[u] = edgeNum++;
}
/*-------------------------树剖------------------------------*/
int deep[maxn],fa[maxn],siz[maxn],son[maxn];
void dfs1(int u,int pre,int d)
{
deep[u] = d;
fa[u] = pre;
siz[u] = 1;
son[u] = 0;
for(int i=head[u];~i;i=e[i].next)
{
int v = e[i].to;
if(v!=pre)
{
dfs1(v,u,d+1);
siz[u] += siz[v];
if(siz[v]>siz[son[u]])
son[u] = v;
}
}
}
int top[maxn],id[maxn],rk[maxn],cnt;
void dfs2(int u,int t)
{
top[u] = t;
id[u] = ++cnt;
rk[cnt] = u;
if(!son[u]) return;
dfs2(son[u],t);
for(int i=head[u];~i;i=e[i].next)
{
int v = e[i].to;
if(v!=son[u]&&v!=fa[u])
dfs2(v,v);
}
}
/*-------------------------树剖------------------------------*/
/*-------------------------线段树------------------------------*/
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
int sum[maxn<<2],lazy[maxn<<2];
void pushup(int rt)
{
sum[rt] = (sum[rt<<1] + sum[rt<<1|1]);
}
void pushdown(int rt,int l,int r)
{
if(lazy[rt])
{
lazy[rt<<1] = (lazy[rt<<1] + lazy[rt]);
lazy[rt<<1|1] = (lazy[rt<<1|1] + lazy[rt]);
sum[rt<<1] += (lazy[rt] * l);
sum[rt<<1|1] += (lazy[rt] * r);
lazy[rt] = 0;
}
}
void update(int L,int R,int val,int l,int r,int rt)
{
if(L<=l&&r<=R)
{
sum[rt] = (sum[rt] + (val) * ((r-l+1)));
lazy[rt] += val;
return ;
}
int m = l + r >> 1;
pushdown(rt,m-l+1,r-m);
if(L<=m)
update(L,R,val,lson);
if(R>m)
update(L,R,val,rson);
pushup(rt);
}
int query(int L,int R,int l,int r,int rt)
{
if(L<=l&&r<=R)
return sum[rt];
int m = l + r >> 1,ans = 0;
pushdown(rt,m-l+1,r-m);
if(L<=m)
ans = (ans + query(L,R,lson));
if(R>m)
ans = (ans + query(L,R,rson));
return ans;
}
/*-------------------------线段树------------------------------*/
/*-----------------------树剖加线段树--------------------------*/
void update(int x,int y,int z)
{
while(top[x]!=top[y])
{
if(deep[top[x]]<deep[top[y]])
swap(x,y);
update(id[top[x]],id[x],z,1,cnt,1);
x = fa[top[x]];
}
if(deep[x]>deep[y])
swap(x,y);
update(id[x],id[y],z,1,cnt,1);
}
int query(int x,int y)
{
int ans = 0;
while(top[x] != top[y])
{
if(deep[top[x]] < deep[top[y]])
swap(x,y);
ans = (ans + query(id[top[x]],id[x],1,cnt,1));//这里下标从1开始
x = fa[top[x]];
}
if(deep[x]>deep[y])
swap(x,y);
ans = (ans + query(id[x],id[y],1,cnt,1));
return ans;
}
/*-----------------------树剖加线段树--------------------------*/
void init()
{
memset(head,-1,4*N+4);
cnt = edgeNum = 0;
}
int u, v, l, r,z;
int main()
{
scanf("%d%d",&N,&Q);
init();
for(int i=2;i<=N;++i)
{
// w[i] = 0;
scanf("%d",&u);
u++;
add(u,i);
add(i,u);
}
dfs1(1,0,0);
dfs2(1,1);
// build(1,cnt,1);
for(int i=1;i<=Q;i++)
{
scanf("%d%d%d",&l,&r,&z);
++l,++r,++z;
v1[l-1].push_back(node{z,-1,i});//结构体存
v1[r].push_back(node{z,1,i});
}
for(int i=1;i<=N;i++){
update(1,i,1);//每次是叠加的
for(int j=0;j<v1[i].size();j++)ans[v1[i][j].id]=(ans[v1[i][j].id]+query(1,v1[i][j].z)*v1[i][j].opt)%mod;
}
for(int i=1;i<=Q;i++)printf("%d\n",ans[i]%mod);
return 0;
}
702
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
