树链剖分（线段树的应用）

最新推荐文章于 2024-06-27 00:50:07 发布
最新推荐文章于 2024-06-27 00:50:07 发布
阅读量609 收藏 2
点赞数
分类专栏： 原始 初学 借鉴

【题目描述】

原题来自：ZJOI 2008

一树上有 n 个节点，编号分别为 1 到 n，每个节点都有一个权值 w。我们将以下面的形式来要求你对这棵树完成一些操作：

1.CHANGE u t ：把节点 u 权值改为 t；

2.QMAX u v ：询问点 u 到点 v 路径上的节点的最大权值；

3.QSUM u v ：询问点 u 到点 v 路径上的节点的权值和。

注意：从点 u 到点 v 路径上的节点包括 u 和 v 本身。

【输入】

第一行为一个数 n，表示节点个数；

接下来 n−1 行，每行两个整数 a,b，表示节点 a 与节点 b 之间有一条边相连；

接下来 n 行，每行一个整数，第 i 行的整数 wi 表示节点 i 的权值；

接下来一行，为一个整数 q ，表示操作总数；

接下来 q 行，每行一个操作，以 CHANGE u t 或 QMAX u v 或 QSUM u v的形式给出。

【输出】

对于每个 QMAX 或 QSUM 的操作，每行输出一个整数表示要求的结果。

【输入样例】
4
1 2
2 3
4 1
4 2 1 3
12
QMAX 3 4
QMAX 3 3
QMAX 3 2
QMAX 2 3
QSUM 3 4
QSUM 2 1
CHANGE 1 5
QMAX 3 4
CHANGE 3 6
QMAX 3 4
QMAX 2 4
QSUM 3 4
【输出样例】
4
1
2
2
10
6
5
6
5
16
【提示】

数据范围与提示：

对于 100% 的数据，有 1≤n≤3×104,0≤q≤2×105 。中途操作中保证每个节点的权值 w 在 −30000 至 30000 之间。

#include<bits/stdc++.h>//xyc大佬讲解的程序
#define lc (k<<1)
#define rc (k<<1|1)
#define mid ((a[k].l+a[k].r)>>1)
using namespace std;
inline void in(int &x){
	int f=1;x=0;char w=getchar();
	while(w<'0'||w>'9'){if(w=='-') f=-f;w=getchar();}
	while(w>='0'&&w<='9'){x=(x<<3)+(x<<1)+(w^48);w=getchar();}
	x*=f;
}
const int N=3e4+10;
struct node{
	int son,fa,deep,size,top,zhi,id;
}p[N];
struct tree{
	int l,r,val,maxn;
}a[N<<2];
int n,m,x,y,tot,cnt;char op[100];
int fir[N],vis[N],rk[N],nxt[N<<1],ver[N<<1];
inline void add(int x,int y){ver[++tot]=y,nxt[tot]=fir[x],fir[x]=tot;}
void dfs1(int x){
	vis[x]=1,p[x].size=1,p[x].deep=p[p[x].fa].deep+1;int maxn=0;
	for(int i=fir[x];i;i=nxt[i]){
		int y=ver[i];if(vis[y]) continue;
		p[y].fa=x,dfs1(y);p[x].size+=p[y].size;
		if(p[y].size>maxn) maxn=p[y].size,p[x].son=y;
	}
}
void dfs2(int x){
	p[x].id=++cnt,rk[cnt]=x,p[x].top=x==p[p[x].fa].son?p[p[x].fa].top:x;
	if(!p[x].son) return ;dfs2(p[x].son);
	for(int i=fir[x];i;i=nxt[i]) {int y=ver[i];if(!p[y].id) dfs2(y);}
}
void build(int k,int l,int r){
	a[k].l=l,a[k].r=r;
	if(l==r) {a[k].maxn=a[k].val=p[rk[l]].zhi;return;}
	build(lc,l,mid),build(rc,mid+1,r);
	a[k].maxn=max(a[lc].maxn,a[rc].maxn);
	a[k].val=a[lc].val+a[rc].val;
}
void add(int k,int x,int z){
	if(a[k].l==a[k].r){a[k].maxn=a[k].val=z;return;}
	if(x<=mid) add(lc,x,z);else add(rc,x,z);
	a[k].maxn=max(a[lc].maxn,a[rc].maxn);
	a[k].val=a[lc].val+a[rc].val;
}
int asksum(int k,int l,int r){
	if(a[k].l>=l&&a[k].r<=r)return a[k].val;
	int ans=0;
	if(l<=mid) ans+=asksum(lc,l,min(r,mid));
	if(r>mid) ans+=asksum(rc,max(mid+1,l),r);
	return ans;
}
int askmax(int k,int l,int r){
	if(a[k].l>=l&&a[k].r<=r)return a[k].maxn;
	int ans=-N;
	if(l<=mid) ans=max(ans,askmax(lc,l,min(mid,r)));
	if(r>mid) ans=max(ans,askmax(rc,max(mid+1,l),r));
	return ans;
}
int main(){
	in(n);for(int i=1;i<n;i++) in(x),in(y),add(x,y),add(y,x);
	for(int i=1;i<=n;i++) in(p[i].zhi);
	dfs1(1),dfs2(1),build(1,1,n),in(m);
	for(int i=1;i<=m;i++){
		scanf("%s",op),in(x),in(y);
		if(op[3]=='X'){
			int ans=-N;
			while(p[x].top!=p[y].top)
			if(p[p[x].top].deep>p[p[y].top].deep)
			ans=max(ans,askmax(1,p[p[x].top].id,p[x].id)),x=p[p[x].top].fa;
			else ans=max(ans,askmax(1,p[p[y].top].id,p[y].id)),y=p[p[y].top].fa;
			ans=max(ans,askmax(1,min(p[x].id,p[y].id),max(p[x].id,p[y].id)));
			printf("%d\n",ans);
		}
		else if(op[3]=='M'){
			int ans=0;
			while(p[x].top!=p[y].top)
			if(p[p[x].top].deep>p[p[y].top].deep)
			ans+=asksum(1,p[p[x].top].id,p[x].id),x=p[p[x].top].fa;
			else ans+=asksum(1,p[p[y].top].id,p[y].id),y=p[p[y].top].fa;
			ans+=asksum(1,min(p[x].id,p[y].id),max(p[x].id,p[y].id));
			printf("%d\n",ans);
		}
		else add(1,p[x].id,y);
	}
	return 0;
}

#include<cstdio>//另一位大佬的注释程序
#include<cstring>
using namespace std;
const int N=31000;
const int M=124000;
int n,q,k=1,first[N],summ,maxmax;
struct Edge{ int v,next;}edge[M];
int num[N];
int father[N],dep[N],size[N],son[N],top[N],seg[N],rev[N];
int maxn[M],sum[M];

int read(){
	int s=0,f=1;
	char ch=getchar();
	while(ch<'0'||ch>'9'){ if(ch=='-') f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){ s=(s<<3)+(s<<1)+ch-48;ch=getchar();}
	return f*s;
}
void addedge(int ui,int vi){
   edge[++k].v=vi;edge[k].next=first[ui];first[ui]=k;
   edge[++k].v=ui;edge[k].next=first[vi];first[vi]=k;	
}
void dfs1(int u,int fa){      //第一遍dfs 
   size[u]=1;          //u的结点数为1，包含它自己 
   father[u]=fa;       //u的父亲为fa 
   dep[u]=dep[fa]+1;   //u的深度为其父亲fa的深度+1
   for(int i=first[u];i;i=edge[i].next){   //穷举与u开头的所有边 
   	 int v1=edge[i].v;
   	 if(v1==fa) continue;
   	 dfs1(v1,u);
   	 size[u]+=size[v1];     //u包含的结点数累加儿子v1的结点
	 if(size[v1]>size[son[u]])   //如果v1的结点数>u的重儿子son[u]的结点数 
	     son[u]=v1;      //更新重儿子 
   }    	
}
void dfs2(int u,int fa){      //第二遍dfs 
	if(son[u]){   //先走重儿子，保证重路径在线段树上的位置是连续的 
		seg[son[u]]=++seg[0];    //重儿子son[u]在线段树上的编号为++seg[0] 
		top[son[u]]=top[u];      //重儿子son[u]所在的重路径的顶端结点为其父亲u所在的顶端结点 
		rev[seg[0]]=son[u];      //线段树上编号为seg[0]的结点号为son[u]
		dfs2(son[u],u);		 
	}
	for(int i=first[u];i;i=edge[i].next){
		int v1=edge[i].v;
		if(top[v1]) continue;   //如果v1已访问过， 即为重儿子或父亲，则不需要再访问
		seg[v1]=++seg[0];  
		rev[seg[0]]=v1;
		top[v1]=v1;    //若(u,v1)为轻边，则v1就是其所在重路径的顶部结点
		dfs2(v1,u); 
	}
}
int max(int x,int y){ if(x>y) return x;return y;}
void build(int k,int l,int r){  //建立线段树
   int mid=(l+r)>>1;
   if(l==r){
   	  maxn[k]=sum[k]=num[rev[l]];
   	  return;
   } 
   build(k<<1,l,mid);
   build((k<<1)+1,mid+1,r);
   sum[k]=sum[k<<1]+sum[(k<<1)+1];
   maxn[k]=max(maxn[k<<1],maxn[(k<<1)+1]);	
}
void change(int k,int l,int r,int val,int pos){  //修改pos结点，改值为val
   if(pos<l||r<pos) return;   //如果不在范围内，就退出 
   if(l==r&&l==pos){    //如果找到点，则更改 
   	  sum[k]=val;
   	  maxn[k]=val;
   	  return;
   } 
   int mid=(l+r)>>1;
   if(mid>=pos) change(k<<1,l,mid,val,pos);    
   if(mid<pos) change((k<<1)+1,mid+1,r,val,pos);
   sum[k]=sum[k<<1]+sum[(k<<1)+1];
   maxn[k]=max(maxn[k<<1],maxn[(k<<1)+1]);	   
}
void swap(int &x,int &y){ int temp=x;x=y;y=temp;}
void query(int k,int l,int r,int x,int y){
	if(y<l||x>r) return;
	if(x<=l&&r<=y){
		summ+=sum[k];
		maxmax=max(maxmax,maxn[k]);
		return;
	}
	int mid=(l+r)>>1;
	if(x<=mid) query(k<<1,l,mid,x,y);
	if(mid<y) query((k<<1)+1,mid+1,r,x,y);
}
void ask(int x,int y){  //路径询问
   int fx=top[x],fy=top[y];  //找到xy分别所在重路径的顶端结点
   while(fx!=fy){       //退出时xy在同一条重路径上 
   	   if(dep[fx]<dep[fy]){   //保证x的深度更大 
   	   	  swap(x,y);swap(fx,fy);  
   	   }
   	   query(1,1,seg[0],seg[fx],seg[x]);
   	   x=father[fx];fx=top[x];
   } 
   if(dep[x]>dep[y]) swap(x,y);    //保证x在线段树上的编号<y
   query(1,1,seg[0],seg[x],seg[y]); 
}
int main(){
    n=read();
    for(int i=1;i<n;++i) addedge(read(),read());
    for(int i=1;i<=n;++i) num[i]=read();
    dfs1(1,0);
    seg[0]=1;    //记录截止到目前线段树的编号 
	seg[1]=1;    //根结点0和1在线段树中的位置为1 
	top[1]=1;   //1所在的重路径顶部结点为1 
	rev[1]=1;   //线段树中第1个位置对应的结点还是1
	dfs2(1,0); 
	build(1,1,seg[0]);    //建立线段树 
	q=read();
	while(q--){
		char st[10];
		scanf("%s",st);
		int ui=read(),vi=read();
		if(st[0]=='C')
		   change(1,1,seg[0],vi,seg[ui]);
		else{
			summ=0;
			maxmax=-100000000;
			ask(ui,vi);
			if(st[1]=='M') printf("%d\n",maxmax);
			else printf("%d\n",summ);
		}
	}	
	return 0;	
}

一次小尝试：

#include<cstdio>
#include<cstring>
using namespace std;
const int N=30005;
struct node{
	int v,next;
}e[N<<1];
int n,y,x,q,w[N],first[N],k=0,cnt=1;
int sum[N<<2],maxn[N<<2];
char st[10];
int sum1,maxn1
int dep[N],fa[N],size[N],son[N],top[N],seg[N]/*表示图中x点在线段树中的编号，即第二次深搜时的时间戳*/,rev[N];
void add(int x,int y){
	e[++k].v=y;e[k].next=first[x];first[x]=k;
}
void dfs1(int u,int fat){
	dep[u]=dep[fa]+1;
	size[u]=1;
	for(i=first[u];i;i=e[i].next){
		int vi=e[i].v;
		if(vi==fat) continue;
		fa[vi]=u;
		dfs1(vi,u);
		size[u]+=size[vi];
		if(size[vi]>size[son[u]]) son[u]=vi;
	}
}
void dfs2(int u,int fat){
	
	if(son[u]){
		seg[son[u]]=++cnt;
		rev[cnt]=son[u];
		top[son[u]]=top[u];
		dfs2(son[u],u);
	}
	for(int i=first[u];i;i=e[i].next){//对轻儿子的操作//即该儿子top为他本身 
		int vi=e[i].v;
		if(vi==fat)continue;
		if(!top[vi]){//表示vi没有访问过 
			seg[vi]=++cnt;
			rev[cnt]=vi;
			top[vi]=vi;
			dfs2(vi,u); 
		}
	}
}
int max(int x,int y){return x > y ? x : y;}
void build(int k,int l,int r){//建立线段树,计算对应的和、最大值 
	if(l==r){
		=w[rev[l]];
		return;
	}
	int mid=(l+r)>>1;
	build(k<<1,l,mid);
	built((k<<1)+1,mid+1,r);
	sum[k]=sum[k<<1]+sum[(k<<1)+1];
	maxn[k]=max(maxn[k<<1],maxn[(k<<1)+1]);
}
void change(int k,int l,int r,int u,int t){
	if(u<l||r<u) return;
	if(l==r&&l==u){
		maxn[k]=sum[k]=t;
		return;
	}
	int mid=(l+r)<<1;
	if(u<=mid) change(k<<1,l,mid,u,t);
	else change((k<<1)+1,mid+1,r,u,t);
	sum[k]=sum[k<<1]+sum[(k<<1)+1];
	maxn[k]=max(maxn[k<<1],maxn[(k<<1)+1]);
}
void query(int k,int l,int r,int x,int y){
	if(y<l||x>r)return;
	if(l<=x&&y<=r){////////////////////////////////////////////////////////
		sum1+=sum[k];
		maxn1=max(maxn1,maxn[k]);
		return;
	}
	int mid=(l+r)<<1;
	if(x<=mid)query(k<<1,l,mid,x,y);
	if(mid+1<=y)query((k<<1)+1,mid+1,r,x,y)
}
int swap(int &x,int &y){int temp=x;x=y;y=temp;}
void ask(int x,int y){
	int fx=top[x],fy=top[y];
	while(fx!=fy){
		if(dep[fx]<dep[fy]){
			swap(x,y),swap(fa,fy);
		}
		query(1,1,n,seg[fx],seg[x]);
		x=fa[fx];
		fx=top[x];
	}
	if(dep[])
}
int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		scanf("%d%d",&x,&y);
		ad(x,y),add(y,x);
	}
	for(int i=1;i<=n;i++)scanf("%d",&w[i]);
	dfs1(1,0);
	seg[1]=cnt;rev[1]=1;top[1]=1;
	dfs2(1,0);
	build(1,1,n);
	scanf("%d",&q);
	while(q--){
		scanf("%s%d%d",st,&x,&y);
		if(st[0]=='C')
			change(1,1,n,seg[x],y);
		else{
			sum1=0;maxn1=-3000000;
			ask(x,y);
			if(st[1]=='M')
			printf("%d",maxn1);
			else
			printf("%d",sum1);
		}
	}
	return 0;
}

又一个标程：

#include<cstdio>
#include<cstring>
#define lc (k<<1)
#define rc (k<<1|1)
using namespace std;
const int N=3e4+5;
struct node{ int vi,next;}edge[N<<1];
int n,k,x,y,cnt=0,q,max1,sum1;
int son[N],fa[N],dep[N],size[N],top[N],id[N],rev[N];
int first[N],w[N],maxn[N<<2],sum[N<<2];
int read(){   //快速读入 
	int s=0,f=1;
	char ch=getchar();
	while(ch<'0'||ch>'9'){ if(ch=='-') f=-1;ch=getchar();	}
	while(ch>='0'&&ch<='9'){ s=(s<<3)+(s<<1)+ch-48;ch=getchar();	}
	return s*f;
}
void ADD(int x,int y){ edge[++k].vi=y;edge[k].next=first[x];first[x]=k;}  //邻接表存储树 
void dfs1(int u,int father){   //第一次深搜 
	fa[u]=father;     //u的父亲是father 
	dep[u]=dep[father]+1;   //u的深度为父亲的深度加1 
	size[u]=1;              //以u为根的子树结点数初始值为1，因为自己也算一个结点 
	for(int i=first[u];i;i=edge[i].next){   //访问u的所有儿子 
		int v=edge[i].vi;
		if(v==father) continue;     //如果儿子为父亲，则不访问，因为是无向图 
		dfs1(v,u);                //深搜儿子 
		size[u]+=size[v];         //u的结点数加上其儿子v的结点数 
		if(size[v]>size[son[u]]) son[u]=v;   //如果v的结点数>u的重儿子的结点数，则更新重儿子 
	}
}
void dfs2(int u){     //第二次深搜 
	id[u]=++cnt;     //u的时间戳是cnt，即在线段树上的编号 
	rev[cnt]=u;      //在线段树上编号位cnt的，对应树上的结点号是u 
	if(son[u]){      //如果u有重儿子 
		top[son[u]]=top[u];     //则u的重儿子son[u]所在重路径的深度最小的顶点=u的重路径顶点 
		dfs2(son[u]);     //深搜重儿子 
	}
	for(int i=first[u];i;i=edge[i].next){   //访问u的所有儿子 
		int v=edge[i].vi;
		if(id[v]) continue;    //如果儿子v访问过，则不需要再次访问，比如重儿子 
		top[v]=v;              //不是重儿子的v的top值为自己 
		dfs2(v);             //深搜儿子 
	}
}
int max(int x,int y){ if(x>y) return x;return y;}
void build(int k,int l,int r){   //建立线段树 
	if(l==r){             //如果是叶子结点 
		maxn[k]=sum[k]=w[rev[l]];  
		return;
	}
	int mid=(l+r)>>1;
	build(lc,l,mid);build(rc,mid+1,r);
	maxn[k]=max(maxn[lc],maxn[rc]);
	sum[k]=sum[lc]+sum[rc];
}
void change(int k,int l,int r,int u,int val){ //将结点u的值改为val
    if(u<l||r<u) return;    //如果u不在区间[l,r]中，则退出 
    if(l==r&&l==u){       //如果找到u，则更新 
    	maxn[k]=sum[k]=val;
		return;
    }	
	int mid=(l+r)>>1;
	if(u<=mid) change(lc,l,mid,u,val);   //如果u在左子树中，则更改左子树 
	else change(rc,mid+1,r,u,val);     //否则更改右子树 
	maxn[k]=max(maxn[lc],maxn[rc]);    //更新区间[l,r]的最大值 
	sum[k]=sum[lc]+sum[rc];      //更新区间[l,r]的和 
}
void swap(int &x,int &y){int temp=x;x=y;y=temp;}
void query(int k,int l,int r,int x,int y){   //询问线段上[x,y]区间上的值 
	if(y<l||r<x) return;    //如果区间[l,r]和[x,y]无交集，则退出 
	if(x<=l&&r<=y){      //如果区间[x,y]包含[l,r]，则更新max1,sum1 
		max1=max(max1,maxn[k]);
		sum1+=sum[k];
		return;
	}
	int mid=(l+r)>>1;
	if(mid>=x) query(lc,l,mid,x,y);    //如果区间[x,y]与[l,mid]有交集，则查找左子树 
	if(mid+1<=y) query(rc,mid+1,r,x,y);	 //如果区间[x,y]与[mid+1,r]有交集，则查找右子树
}
void ask(int u,int v){      //询问树上结点u,v之间的值 
	while(top[u]!=top[v]){     //如果u,v不在一个重路径上 
		if(dep[top[u]]<dep[top[v]]){ swap(u,v);	}   //保证top[u]的深度大于top[v]，否则交换两者 
		query(1,1,n,id[top[u]],id[u]);    //因为后面u要跳到top[u]的父亲处，故要将u~top[u]之间的路径上的值更新，其在线段树上的编号是连续的，即id[u ~id[top[u]]
		u=fa[top[u]];     //u跳到其top[u]的父亲处 
	}
	if(dep[u]<dep[v]) swap(u,v);   //while结束时，u和v必然在同一个重路径上，if是为了保证u的深度大于v 
	query(1,1,n,id[v],id[u]);   //结点v~u在线段树上的编号是连续的，故查找id[v]~id[u] 
}

int main(){
	//freopen("count.in","r",stdin);freopen("count.out","w",stdout);
	n=read();
	for(int i=1;i<n;++i){ x=read();y=read();ADD(x,y);ADD(y,x);}
	for(int i=1;i<=n;++i) w[i]=read();
	dfs1(1,0);
	dfs2(1);
	//for(int i=1;i<=n;++i)   printf("%d:son%d fa%d dep%d size%d top%d id%d rev%d\n",i,son[i],fa[i],dep[i],size[i],top[i],id[i],rev[i] );
	build(1,1,cnt);
	q=read();
	while(q--){
		char st[10];
		scanf("%s",st);x=read();y=read();
		if(st[0]=='C')
		   change(1,1,n,id[x],y);
	    else{
	       max1=-3000000;sum1=0;
	       ask(x,y);
	       if(st[1]=='M') printf("%d\n",max1);
	       else printf("%d\n",sum1);
	    }		
	}	
	//fclose(stdin);fclose(stdout);
	return 0;
}
树链剖分+线段树
XHRlyb的博客
08-26 751
之前就学过树链剖分的原理，只会树链剖分LCA，今天做了一道“树链剖分+数据结构”的题，虽然很简单，但可以当模板用一用，粘到这里。树链剖分简单描述（可能不大对）： 第一步就是划分轻重边，按每一棵子树的大小，与形成子树最大的一个子节点是重边，其余为轻边，然后就得到了轻重链。 之后就可以用数据结构维护一些东西了，可以是点也可以是边。 对节点 x 到 y 间的路径进行操作时，分别找到 x 和 y 所在链（
树链剖分
Lazier’s blog
12-14 708
原文地址：树链剖分作者：starszys  “在一棵树上进行路径的修改、求极值、求和”乍一看只要线段树就能轻松解决，实际上，仅凭线段树是不能搞定它的。我们需要用到一种貌似高级的复杂算法——树链剖分。     树链，就是树上的路径。剖分，就是把路径分类为重链和轻链。     记siz[v]表示以v为根的子树的节点数，dep[v]表示v的深度(根深度为1)，top[v]表
树链剖分原理与应用
weixin_30809173的博客
08-13 141
树链剖分这个算法我看了好多大神们的博客，才慢慢领悟，希望我写的过得去( · · ) 众所周知，维护区间信息的题目可以用线段树高效实现。类似于区间这样一维的结构，在树上维护两点间的信息【比如树上两点之间的最大值】也可以用线段树吗？ 仔细想想，好像很难实现。因为线段树维护的是链状结构，而树是一张图。 但我们想想，如果能把一棵树化为一条链，使得要节点间编号是一段一段的【也就是有些节点间的...
树链剖分与线段树
实践求真知
11-02 472
算法和数据结构
NOIP树链剖分习题讲解报告
11-01
此题同样是关于树链剖分的应用，但涉及的操作更为复杂。除了基本的树链剖分外，还需要额外考虑如何高效地更新节点值以及求解子树的和。具体的解决方案包括： 1. **预处理阶段：** - 计算每个节点的深度、子树大小...
树链剖分及其应用_蒋一瑶.pptx
09-14
在实际应用中，树链剖分广泛应用于动态维护树上的路径信息，如LCA（最近公共祖先）、树上的最短路径等问题，以及解决各种树形结构中的查询和更新问题。例如，在图论的竞赛编程题目中，树链剖分是解决动态路径信息...
树链剖分_王天懿.ppt
09-14
1. **POJ 3237**：维护边权的修改和路径上边权的取反操作，可以利用树链剖分和线段树联合解决。 2. **BZOJ 3083**：改变路径上点的权值和查询子树最小值，同样可以通过树链剖分实现。 3. **BZOJ 3531**：改变点的...
NOIP树链剖分详解与实现
五、树链剖分的应用 1. 查询和更新：在树链剖分后，可以快速查询节点间的路径信息，例如查找两点间最短路径，求节点到根节点的路径上的某个性质等。 2. 广义LCA（最近公共祖先）：利用树链剖分，可以实现在线查询两...
树链剖分及应用
weixin_43184669的博客
02-06 551
定义：   将整棵树剖分为若干条链，使它组合成线性结构，然后用其他的数据结构维护信息。就是一种技巧，为了方便处理问题。   形式：重链剖分，长链剖分等。此处讲述重链剖分。 重链剖分：   可以将树上的任意一条路径划分成不超过 lognlognlogn 条连续的链，每条链上的点深度互不相同（即是自底向上的一条链，链上所有点的 LCALCALCA 为链的一个端点）。还能保证划分出的每条链上的节点 DF...
[hdu5405] sometimes naive——树链剖分+线段树
ylsoi的博客
01-12 2532
[hdu5405]sometimes naive Problem Description Rhason Cheung had a naive problem, and asked Teacher Mai for help. But Teacher Mai thought this problem was too simple, sometimes naive. So she ask you...
树链剖分+线段树--CF1076E Vasya and a Tree
继续学吧
12-04 235
传送门 题意就是给你一颗nnn个点的树，一开始权值都是000，然后mmm个操作，每个操作对一个点xxx的子树中到它距离不超过ddd的点权都加上valvalval，问最后所有点的点权是多少 对于子树的修改可以用树剖+线段树做到，但是对于半个子树的修改很难做到，那就可以将修改操作排一下序，按照dep[x]+ddep[x]+ddep[x]+d从大到小排，这样的话当修改完了一层，后面的修改都不会修改到这一...
线段树+树链剖分全纪录
Coco_T的博客
03-25 505
线段树 最基础线段树，就是支持区间加乘，查询区间最值 总的来说，就是可以在区间上进行操作 （给出的可能不是完整代码，不过都是精华） 代码中有几个细节需要注意： 默认先乘后加，在计算值的时候统一表达式： t[bh].sum=( t[bh].sum*t[bh].mul%p + (t[bh].y-t[bh].x+1)*t[bh].ad%p )%p; 永远记住：先维护值,再下传标记 标记下...
bzoj 3683: Falsita 树链剖分+线段树
beginend
02-15 1461
题意给出一棵有根树，一开始每个节点都有一个权值。要求资瓷三个操作： S x delta节点x的权值增加delta M x delta以x为根的子树的所有节点的权值增加delta Q x询问(∑lca(p,q)==xv[p]+v[q])/(∑lca(p,q)==x)(\sum_{lca(p,q)==x}v[p]+v[q])/(\sum lca(p,q)==x) n,m<=300000分析一开始
51nod 1618 树或非树 树链剖分+线段树
beginend
10-24 637
题意G是一张由n个点和n条边组成的无向图。G中没有自环和重边。每条边有两种状态“开”和“关”。一开始，所有的边都是“关”着的。 现在有m个操作(v,u)，表示将从v到u的最短路上的边改变状态（如果状态为“开”则变成“关”，反之，变成“开”）。如果v到u存在多条最短路，则我们选取点序列字典序最小的那一条。 比如，将所有从v到u的路径上的点表示成序列为 v，v1，v2，…，u 。那么我们从中取字典序
P3178 树链剖分 线段树 子树加
刷题记录
07-22 186
题目 输入样例#1： 5 5 1 2 3 4 5 1 2 1 4 2 3 2 5 3 3 1 2 1 3 5 2 1 2 3 3 输出样例#1： 6 9 13 说明 对于 100% 的数据， N,M<=100000 ，且所有输入数据的绝对值都不会超过 10^6 因为子树的dfs序连续，所以直接区间加pos[u]+siz[u]-1，便可实现子树加; #include<bits/stdc+...
树链剖分（2）树剖的较高级应用（P3384 【模板】树链剖分）
guapi2333的博客
10-22 264
参照洛谷模板 P3384 【模板】树链剖分 题意： 给你一棵包含n个结点的树，现要求你支持以下操作: 1.x到y结点最短路径上所有节点的值都加上z； 2.求树从x到y结点最短路径上所有节点的值之和； 3.将以x为根节点的子树内所有节点值都加上z； 4.求以x为根节点的子树内所有节点值之和。 正确的思路是树链剖分套线段树。 我们可以求一个dfs序(dfn[])，这个dfs序与之前求to...
树链剖分及其应用
最新发布
Se_ren_di_pity的博客
06-27 532
1.重儿子：假设节点u有n个子结点,其中以v子节点的为根子树的大小最大，那么v就是u的重儿子。只需要让top[u]的深度较大的一方跳到其top[u]的父亲结点上，自然就到了另一条新链了。首先，我们可以很简单地通过dfs获取一个结点的dep,fa和siz，从而也就获得了siz。假设他们在同一条链上，也就是top相同，那么他们的lca就是深度比较小的一方。siz[u]：以u节点为根的子树的大小。重儿子的top就等于自己u节点的top。top[u]：u结点所在的链的顶点。4.重边：结点u与重儿子连接的边。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值