树链剖分相关

最新推荐文章于 2024-09-11 00:45:00 发布
最新推荐文章于 2024-09-11 00:45:00 发布
阅读量77 收藏 1
点赞数
文章标签： 树链剖分
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44574520/article/details/100750576
版权

[ZJOI2008]树的统计

#include <bits/stdc++.h>
using namespace std;
#define maxn 30010

int AKIOI_maxd,AKIOI_sum,n,m,tot=0,head[maxn],top[maxn],rev[maxn],seg[maxn],f[maxn],w[maxn],dep[maxn],size[maxn],son[maxn];
struct edge {
	int v,nxt;
}e[maxn<<1];
char s[10];

inline int read_() {
	int x_=0,f_=1;char c_=getchar();
	while(c_<'0'||c_>'9') {if(c_=='-') f_=-1;c_=getchar();}
	while(c_>='0'&&c_<='9') {x_=(x_<<1)+(x_<<3)+c_-'0';c_=getchar();}
	return x_*f_;
}

inline void add_(int u,int v) {
	e[++tot].v=v;
	e[tot].nxt=head[u];
	head[u]=tot;
}

void dfs_1_(int u,int fa) {
	dep[u]=dep[fa]+1;
	f[u]=fa;
	size[u]=1;
	for(int i=head[u];~i;i=e[i].nxt) {
		int v=e[i].v;
		if(v==fa) continue;
		dfs_1_(v,u);
		size[u]+=size[v];
		if(size[v]>size[son[u]]) son[u]=v;
	}
}

void dfs_2_(int u,int fa) {
	if(son[u]) {
		seg[son[u]]=++seg[0];
		top[son[u]]=top[u];
		rev[seg[0]]=son[u];
		dfs_2_(son[u],u);
	}
	for(int i=head[u];~i;i=e[i].nxt) {
		int v=e[i].v;
		if(!top[v]) {
			seg[v]=++seg[0];
			top[v]=v;
			rev[seg[0]]=v;
			dfs_2_(v,u);
		}
	}
}

struct seg_tree {
	struct node {
		int maxd,sum;
	}tr[maxn<<2];

#define lson l,mid,nod<<1
#define rson mid+1,r,nod<<1|1
	
	inline void pushup_(int nod) {
		tr[nod].maxd=max(tr[nod<<1].maxd,tr[nod<<1|1].maxd);
		tr[nod].sum=tr[nod<<1].sum+tr[nod<<1|1].sum;
	}
	void build_(int l,int r,int nod) {
		if(l==r) {
			tr[nod].maxd=tr[nod].sum=w[rev[l]];
			return;
		}
		int mid=(l+r)>>1;
		build_(lson);build_(rson);
		pushup_(nod);
	}
	void update_(int l,int r,int nod,int k,int v) {
		if(l==r&&l==k) {
			tr[nod].maxd=tr[nod].sum=v;
			return;
		} 
		int mid=(l+r)>>1;
		if(k<=mid) update_(lson,k,v);
		else update_(rson,k,v);
		pushup_(nod);
	}
	void query_(int l,int r,int nod,int LL,int RR) {
		if(LL<=l&&RR>=r) {
			AKIOI_maxd=max(AKIOI_maxd,tr[nod].maxd);
			AKIOI_sum+=tr[nod].sum;
			return;
		}
		int mid=(l+r)>>1;
		if(LL<=mid) query_(lson,LL,RR);
		if(RR>mid) query_(rson,LL,RR);
	}
}tree_;

inline void solve_(int x,int y) {
	AKIOI_maxd=-2139062143,AKIOI_sum=0;
	int fx=top[x],fy=top[y];
	while(fx!=fy) {
		if(dep[fx]<dep[fy]) swap(x,y),swap(fx,fy);
		tree_.query_(1,seg[0],1,seg[fx],seg[x]);
		x=f[fx];fx=top[x];
	}
	if(dep[x]>dep[y]) swap(x,y);
	tree_.query_(1,seg[0],1,seg[x],seg[y]);
}

void readda_(){
	n=read_();
	int x,y;memset(head,-1,sizeof(head));
	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_();
	dfs_1_(1,0);
	seg[0]=seg[1]=top[1]=rev[1]=1;
	dfs_2_(1,0);
	tree_.build_(1,seg[0],1);
	m=read_();
	while(m--) {
		scanf("%s",s);
		x=read_();y=read_();
		if(s[0]=='C') {
			tree_.update_(1,seg[0],1,seg[x],y);
		}
		else if(s[1]=='M') {
			solve_(x,y);
			printf("%d\n",AKIOI_maxd);
		}
		else if(s[1]=='S') {
			solve_(x,y);
			printf("%d\n",AKIOI_sum);
		}
	}
}

int main() {
//	freopen("a.txt","r",stdin);
	readda_();
	return 0;
}

换根树链剖分

#include <bits/stdc++.h>
using namespace std;
#define maxn 100010

int root,m,n,w[maxn],head[maxn],dep[maxn],top[maxn],seg[maxn],rev[maxn],f[maxn],size[maxn],son[maxn],tot=0;
struct edge {
	int v,nxt;
}e[maxn<<1];

inline int read_() {
	int x_=0,f_=1;char c_=getchar();
	while(c_<'0'||c_>'9') {if(c_=='-') f_=-1;c_=getchar();}
	while(c_>='0'&&c_<='9') {x_=(x_<<1)+(x_<<3)+c_-'0';c_=getchar();}
	return x_*f_;
}

inline void add_(int u,int v) {
	e[++tot].v=v;
	e[tot].nxt=head[u];
	head[u]=tot;
}

void dfs_1_(int u,int fa) {
	dep[u]=dep[fa]+1;
	f[u]=fa;size[u]=1;
	for(int i=head[u];~i;i=e[i].nxt) {
		int v=e[i].v;
		if(v==fa) continue;
		dfs_1_(v,u);
		size[u]+=size[v];
		if(size[v]>size[son[u]]) son[u]=v;
	}
}

void dfs_2_(int u,int fa) {
	if(son[u]) {
		seg[son[u]]=++seg[0];
		top[son[u]]=top[u];
		rev[seg[0]]=son[u];
		dfs_2_(son[u],u);
	}
	for(int i=head[u];~i;i=e[i].nxt) {
		int v=e[i].v;
		if(v==fa) continue;
		if(!top[v]) {
			seg[v]=++seg[0];
			top[v]=v;
			rev[seg[0]]=v;
			dfs_2_(v,u);
		}
	}
}

struct seg_tree {
	struct node {
		long long sum,la;
	}tr[maxn<<2];
	#define lson l,mid,nod<<1
	#define rson mid+1,r,nod<<1|1
	inline void pushup_(int nod) {
		tr[nod].sum=tr[nod<<1].sum+tr[nod<<1|1].sum;
	}
	void build_(int l,int r,int nod) {
		if(l==r) {
			tr[nod].sum=w[rev[l]];
			return ;
		}
		int mid=(l+r)>>1;
		build_(lson);build_(rson);
		pushup_(nod);
	}
	inline void xiugai_(int l,int r,int nod,long long v) {
		tr[nod].sum += ( r-l+1 ) * v; tr[nod].la += v;
	}
	void update_(int l,int r,int nod,int LL,int RR,long long v) {
		if(LL<=l&&RR>=r) {
			xiugai_(l,r,nod,v);
			return ;
		}
		int mid=(l+r)>>1;
		if(tr[nod].la!=0) {
			xiugai_(lson,tr[nod].la);xiugai_(rson,tr[nod].la);tr[nod].la=0;
		}
		if(LL<=mid) update_(lson,LL,RR,v);
		if(RR>mid) update_(rson,LL,RR,v);
		pushup_(nod);
	}
	long long query_(int l,int r,int nod,int LL,int RR) {
		if(LL<=l&&RR>=r) return tr[nod].sum;
		int mid=(l+r)>>1;
		if(tr[nod].la!=0) {
			xiugai_(lson,tr[nod].la);xiugai_(rson,tr[nod].la);tr[nod].la=0;
		}
		long long ans=0;
		if(LL<=mid) ans+=query_(lson,LL,RR);
		if(RR>mid) ans+=query_(rson,LL,RR);
		return ans;
	}
}tree_;

inline int LCA_(int x,int y) {
	while(top[x]!=top[y]) {
		if(dep[top[x]]<dep[top[y]]) swap(x,y);
		x=f[top[x]];
	}
	if(dep[x]>dep[y]) swap(x,y);
	return x;
}

inline int find_(int x,int y) {
	while(top[x]!=top[y]) {
		if(dep[top[x]]<dep[top[y]]) swap(x,y);
		if(f[top[x]]==y) return top[x];
		x=f[top[x]];
	}
	if(dep[x]>dep[y]) swap(x,y);
	return son[x];
}

inline void solve_2_(int x,int y,long long z) {
	while(top[x]!=top[y]) {
		if(dep[top[x]]<dep[top[y]]) swap(x,y);
		tree_.update_(1,seg[0],1,seg[top[x]],seg[x],z);
		x=f[top[x]];
	}
	if(dep[x]>dep[y]) swap(x,y);
	tree_.update_(1,n,1,seg[x],seg[y],z);
}

inline void solve_3_(int x,long long z) {
	if(x==root) return tree_.update_(1,n,1,1,n,z);
	int lca=LCA_(x,root);
	if(lca!=x) return tree_.update_(1,n,1,seg[x],seg[x]+size[x]-1,z);
	else {
		int ch=find_(x,root);
		tree_.update_(1,n,1,1,n,z);
		tree_.update_(1,n,1,seg[ch],seg[ch]+size[ch]-1,-z);
		return ;
	}
} 

inline void solve_4_(int x,int y) {
	long long AKIOI=0;
	while(top[x]!=top[y]) {
		if(dep[top[x]]<dep[top[y]]) swap(x,y);
		AKIOI+=tree_.query_(1,n,1,seg[top[x]],seg[x]);
		x=f[top[x]];
	}
	if(dep[x]>dep[y]) swap(x,y);
	AKIOI+=tree_.query_(1,n,1,seg[x],seg[y]);
	printf("%lld\n",AKIOI);
}

inline void solve_5_(int x) {
	long long AKIOI=0;
	if(x==root) {
		AKIOI=tree_.query_(1,n,1,1,n);
		printf("%lld\n",AKIOI);
		return ;
	}
	int lca=LCA_(x,root);
	if(lca!=x) AKIOI=tree_.query_(1,n,1,seg[x],seg[x]+size[x]-1);
	else {
		int ch=find_(x,root);
		AKIOI=tree_.query_(1,n,1,1,n);
		AKIOI-=tree_.query_(1,n,1,seg[ch],seg[ch]+size[ch]-1);
	}
    printf("%lld\n",AKIOI);
	return ;
}

void readda_() {
	n=read_();
	for(int i=1;i<=n;++i) w[i]=read_();
	int x;memset(head,-1,sizeof(head));
	for(int i=2;i<=n;++i) {
		x=read_();add_(i,x);add_(x,i);
	}
	dfs_1_(1,0);
	seg[0]=seg[1]=rev[1]=top[1]=1;
	dfs_2_(1,0);
	tree_.build_(1,seg[0],1);
	m=read_();root=1;
	int pd,y,z;
	while(m--) {
		pd=read_(); 
		if(pd==1) {
			x=read_();
			root=x;
		}
		else if(pd==2) {
			x=read_();y=read_();z=read_();
			solve_2_(x,y,(long long)z);
		}
		else if(pd==3) {
			x=read_();z=read_();
			solve_3_(x,(long long) z);
		}
		else if(pd==4) {
			x=read_();y=read_();
			solve_4_(x,y);
		}
		else if(pd==5) {
			x=read_();
			solve_5_(x);
		}
	}
}

int main() {
	readda_();
	return 0;
}

【模板】树链剖分

  • 注意 d f s 2 dfs_2 dfs2​时不要把 t o p [ u ] top[u] top[u]打成 u u u
#include <bits/stdc++.h>
using namespace std;
#define maxn 100010

int n,m,root,w[maxn],mod,tot=0,head[maxn],f[maxn],seg[maxn],top[maxn],rev[maxn],size[maxn],son[maxn],dep[maxn];
long long ans=0;
struct edge {
   int v,nxt;
}e[maxn<<1];

inline int read_() {
   int x_=0,f_=1;char c_=getchar();
   while(c_<'0'||c_>'9') {if(c_=='-') f_=-1;c_=getchar();}
   while(c_>='0'&&c_<='9') {x_=(x_<<1)+(x_<<3)+c_-'0';c_=getchar();}
   return x_*f_;
}

inline void add_(int u,int v) {
   e[++tot].v=v;
   e[tot].nxt=head[u];
   head[u]=tot;
}

void dfs_1_(int u,int fa) {
   dep[u]=dep[fa]+1;
   f[u]=fa;size[u]=1;
   for(int i=head[u];~i;i=e[i].nxt) {
   	int v=e[i].v;
   	if(v==fa) continue;
   	dfs_1_(v,u);
   	size[u]+=size[v];
   	if(size[v]>size[son[u]]) son[u]=v;
   }
}

void dfs_2_(int u,int fa) {
   if(son[u]) {
   	seg[son[u]]=++seg[0];
   	top[son[u]]=top[u];
   	rev[seg[0]]=son[u];
   	dfs_2_(son[u],u);
   }
   for(int i=head[u];~i;i=e[i].nxt) {
   	int v=e[i].v;
   	if(v==fa) continue;
   	if(!top[v]) {
   		seg[v]=++seg[0];
   		top[v]=v;
   		rev[seg[0]]=v;
   		dfs_2_(v,u);
   	}
   }
}

struct seg_tree {
   long long sum[maxn<<2],la[maxn<<2];
   #define lson l,mid,nod<<1
   #define rson mid+1,r,nod<<1|1
   inline void pushup_(int nod) {
   	sum[nod]=sum[nod<<1]+sum[nod<<1|1];
   	sum[nod]%=mod;
   }
   void build_(int l,int r,int nod) {
   	if(l==r) {
   		sum[nod]=w[rev[l]];
   		sum[nod]%=mod;
   		return;
   	}
   	int mid=(l+r)>>1;
   	build_(lson);build_(rson);
   	pushup_(nod);
   }
   inline void xiugai_(int l,int r,int nod,int v) {
   	sum[nod]+=(long long) (r-l+1) * v;sum[nod]%=mod;
   	la[nod]+=v;
   }
   void update_(int l,int r,int nod,int LL,int RR,int v) {
   	if(LL<=l&&RR>=r) {
   		xiugai_(l,r,nod,v);
   		return;
   	}
   	int mid=(l+r)>>1;
		if(la[nod]!=0) {
			xiugai_(lson,la[nod]);xiugai_(rson,la[nod]);la[nod]=0;
   	}
		if(LL<=mid) update_(lson,LL,RR,v);
		if(RR>mid) update_(rson,LL,RR,v);
		pushup_(nod);
   }
   void query_(int l,int r,int nod,int LL,int RR) {
   	if(LL<=l&&RR>=r) {
   		ans+=sum[nod];ans%=mod;
   		return ;
   	}
   	int mid=(l+r)>>1;
   	if(la[nod]!=0) {
   		xiugai_(lson,la[nod]);xiugai_(rson,la[nod]);la[nod]=0;
   	}
   	if(LL<=mid) query_(lson,LL,RR);
   	if(RR>mid) query_(rson,LL,RR);
   }
}tree_;

inline void solve_update_(int x,int y,int z) {
   z%=mod;
   int fx=top[x],fy=top[y];
   while(fx!=fy) {
   	if(dep[fx]<dep[fy]) {
   		swap(fx,fy); swap(x,y);
   	}
   	tree_.update_(1,n,1,seg[fx],seg[x],z);
   	x=f[fx];fx=top[x];
   }
   if(dep[x]>dep[y]) swap(x,y);
   tree_.update_(1,n,1,seg[x],seg[y],z);
}

inline void solve_query_(int x,int y) {
   int fx=top[x],fy=top[y];
   while(fx!=fy) {
   	if(dep[fx]<dep[fy]) {
   		swap(fx,fy);swap(x,y);
   	}
   	tree_.query_(1,n,1,seg[fx],seg[x]);
   	x=f[fx];fx=top[x];ans%=mod;
   }
   if(dep[x]>dep[y]) swap(x,y);
   tree_.query_(1,n,1,seg[x],seg[y]);  ans%=mod;
}

void readda_(){
   n=read_();m=read_();root=read_();mod=read_();
   for(int i=1;i<=n;++i) w[i]=read_();
   int x,y;memset(head,-1,sizeof(head));
   for(int i=1;i<n;++i) {
   	x=read_();y=read_();
   	add_(x,y);add_(y,x);
   }
   dfs_1_(root,0);
   seg[0]=1;top[root]=root;seg[root]=1;rev[1]=root;
   dfs_2_(root,0);
   tree_.build_(1,n,1);
   int pd,z;
   while(m--) {
   	pd=read_();x=read_();
   	if(pd==1) {
   		y=read_();z=read_();
   		solve_update_(x,y,z);
   	}
   	else if(pd==2) {
   		y=read_();ans=0;
   		solve_query_(x,y);
   		printf("%lld\n",ans%mod);
   	}
   	else if(pd==3) {
   		z=read_();
   		tree_.update_(1,n,1,seg[x],seg[x]+size[x]-1,z);
   	}
   	else if(pd==4) {
   		ans=0;
   		tree_.query_(1,n,1,seg[x],seg[x]+size[x]-1);
   		printf("%lld\n",ans%mod);
   	}
   }
}

int main() {
//	freopen("a.txt","r",stdin);
   readda_();
   return 0;
}

[HAOI2015]树上操作

  • 注意线段树修改函数的 v v v要开成 l o n g long long l o n g long long
#include <bits/stdc++.h>
using namespace std;
#define maxn 100010

int f[maxn],size[maxn],son[maxn],seg[maxn],top[maxn],rev[maxn],dep[maxn],n,m,tot=0,head[maxn],w[maxn];
long long ans;
struct edge {
	int v,nxt;
}e[maxn<<1];

inline int read_() {
	int x_=0,f_=1;char c_=getchar();
	while(c_<'0'||c_>'9') {if(c_=='-') f_=-1;c_=getchar();}
	while(c_>='0'&&c_<='9') {x_=(x_<<1)+(x_<<3)+c_-'0';c_=getchar();}
	return x_*f_;
}

inline void add_(int u,int v) {
	e[++tot].v=v;
	e[tot].nxt=head[u];
	head[u]=tot;
}

void dfs_1_(int u,int fa) {
	dep[u]=dep[fa]+1;
	f[u]=fa;size[u]=1;
	for(int i=head[u];~i;i=e[i].nxt) {
		int v=e[i].v;
		if(v==fa) continue;
		dfs_1_(v,u);
		size[u]+=size[v];
		if(size[v]>size[son[u]]) son[u]=v;
	}
}

void dfs_2_(int u,int fa) {
	if(son[u]) {
		seg[son[u]]=++seg[0];
		top[son[u]]=top[u];
		rev[seg[0]]=son[u];
		dfs_2_(son[u],u);
	}
	for(int i=head[u];~i;i=e[i].nxt) {
		int v=e[i].v;
		if(v==fa) continue;
		if(!top[v]) {
			seg[v]=++seg[0];
			top[v]=v;
			rev[seg[0]]=v;
			dfs_2_(v,u);
		}
	}
}

struct seg_tree {
	struct node {
		long long sum,la;
	}tr[maxn<<2];
	#define lson l,mid,nod<<1
	#define rson mid+1,r,nod<<1|1
	inline void pushup_(int nod) {
		tr[nod].sum=tr[nod<<1].sum+tr[nod<<1|1].sum;
	}
	void build_(int l,int r,int nod) {
		if(l==r) {
			tr[nod].sum=w[rev[l]];
			return;
		}
		int mid=(l+r)>>1;
		build_(lson);build_(rson);
		pushup_(nod);
	}
	inline void xiugai_(int l,int r,int nod,long long v) {
		tr[nod].sum+=(r-l+1) * v;tr[nod].la+=v;
	}
	void update_(int l,int r,int nod,int LL,int RR,long long v) {
		if(LL<=l&&RR>=r) {
			xiugai_(l,r,nod,v);
			return ;
		}
		int mid=(l+r)>>1;
		if(tr[nod].la!=0) {
			xiugai_(lson,tr[nod].la);xiugai_(rson,tr[nod].la);tr[nod].la=0;
		}
		if(LL<=mid) update_(lson,LL,RR,v);
		if(RR>mid) update_(rson,LL,RR,v);
		pushup_(nod); 
	}
	void query_(int l,int r,int nod,int LL,int RR) {
		if(LL<=l&&RR>=r) {
			ans+=tr[nod].sum;
			return;
		}
		int mid=(l+r)>>1;
		if(tr[nod].la!=0) {
			xiugai_(lson,tr[nod].la);xiugai_(rson,tr[nod].la);tr[nod].la=0;
		}
		if(LL<=mid) query_(lson,LL,RR);
		if(RR>mid) query_(rson,LL,RR);
	}
}tree_;

inline void solve_query_(int x,int y) {
	int fx=top[x],fy=top[y];
	while(fx!=fy) {
		if(dep[fx]<dep[fy]) {
			swap(fx,fy);swap(x,y);
		}
		tree_.query_(1,seg[0],1,seg[fx],seg[x]);
		x=f[fx];fx=top[x];
	}
	if(dep[x]>dep[y]) swap(x,y);
	tree_.query_(1,seg[0],1,seg[x],seg[y]);
}
void readda_() {
	n=read_();m=read_();
	for(int i=1;i<=n;++i) w[i]=read_();
	int x,y;memset(head,-1,sizeof(head));
	for(int i=1;i<n;++i) {
		x=read_();y=read_();
		add_(x,y);add_(y,x);
	}
	dfs_1_(1,0);
	seg[0]=seg[1]=rev[1]=top[1]=1;
	dfs_2_(1,0);
	tree_.build_(1,seg[0],1);
	int pd;
	while(m--) {
		pd=read_();x=read_();
		if(pd==1) {
			y=read_();
			tree_.update_(1,seg[0],1,seg[x],seg[x],(long long)y);
		}
		else if(pd==2) {
			y=read_();
			tree_.update_(1,seg[0],1,seg[x],seg[x]+size[x]-1,(long long)y);
		}
		else if(pd==3) {
			ans=0;
			solve_query_(1,x);
			printf("%lld\n",ans);
		}
	}
}

int main() {
	freopen("a.txt","r",stdin);
	readda_();
	return 0;
}
小元勋
关注
NOIP 树链剖分 NOIP 树链剖分
10-30
#### 一、树链剖分的相关概念 **剖分目的**：树链剖分的主要目的是为了更高效地处理树状结构上的路径信息维护问题，例如路径上的权值更新或查询等操作。通过树链剖分，可以将这些操作的时间复杂度降低至对数级别。 ...
第5章 树链剖分 测试数据.rar
12-02
树链剖分是一种高效处理树型结构的算法，尤其在解决与树的边查询和修改有关的问题时，它能提供显著的效率提升。这一技术在信息学奥赛中经常被用到，帮助参赛者快速解决复杂的树形问题。在本章的测试数据中，你将有...
树链剖分总结
ZhuRanCheng的博客
05-22 668
树链剖分总结
树链剖分（重链剖分）
m0_73666576的博客
03-24 2200
本文主要针对于还没有学习过这个算法的新手同学
树链剖分
orz
07-07 122
模板 例题 #include <bits/stdc++.h> #define int long long #define ld lld #define _ 500005 #define ls(a) a << 1 #define rs(a) a << 1 | 1 using namespace std; int n, m, r, p; int op, x, y, z; int a[_], b[_]; int head[_], to[_], nxt[_], tot; int
树链剖分详解
2301_79974919的博客
09-11 1830
前置概念：size[i]表示节点i的子树大小，其中子树大小定义为包括该点自身的子树含有的节点数个数。轻儿子和重儿子：一个节点儿子中size最大的叫做，剩下的都叫。轻重边：连接x及其重儿子的边叫做重边，同理连接x及其轻儿子的边叫做轻边轻重链：多条重边形成的链叫做重链，且规定每个节点都属于某一条重链。top[i]表示i节点所在重链的顶端的点的编号f[i]表示i节点的父节点编号son[i]表示i节点的重儿子编号，编号为0代表无重儿子d[i]表示i节点的深度，规定根节点深度为1。
哇！树链剖分（树链剖分详解）
TengMaxJun的博客
04-07 997
顾名思义，重链剖分就是把”重“的链与其他的链分开。
树链剖分与线段树
实践求真知
11-02 334
算法和数据结构
树链剖分 模板小记
绫
07-21 155
树链剖分 模板小记树链剖分~模板小记树链剖分 模板小记 Q.Q.Q. 树链剖分的背景？ A.A.A. 连通且无环的树 Q.Q.Q. 树链剖分的作用？ A.A.A. 大幅增加码量 （ A.A.A. 将一棵树变成几条链 树形变成线形 减少处理难度 Q.Q.Q. 树链剖分能处理哪些问题？ A1.A_1.A1​. 修改的有： 将xxx节点+ or×val+~or\times val+ or×val 将xxx到yyy这条路径上所有节点+ or×val+~or\t
树链剖分(一）-重链剖分：模板&例题
Mint_hexagram的博客
02-25 657
重链剖分的模板学习及基础模板练习
【数据结构】树链剖分
Video_game的博客
12-11 1393
树链剖分
树链剖分模板
08-08
第一遍dfs求出树每个结点的深度deep[x]，其为根的子树大小size[x] 以及祖先的信息fa[x][i]表示x往上距离为2^i的祖先 第二遍dfs 根节点为起点，向下拓展构建重链 选择最大的一个子树的根继承当前重链 其余节点，都...
VB程序实例-图像动画.zip
11-03
VB程序实例-图像动画.zip
VB程序实例-艺术窗口.zip
11-03
VB程序实例-艺术窗口.zip
媒体分析小米公司的供应链存在的隐患,商业资讯-商务联盟.html
11-03
媒体分析小米公司的供应链存在的隐患,商业资讯_商务联盟.html
pytz-2021.1-py2.py3-none-any.whl
最新发布
11-03
pytz库的主要功能 时区转换：pytz库允许用户将时间从一个时区转换到另一个时区，这对于处理跨国业务或需要处理多地时间的数据分析尤为重要。 历史时区数据支持：pytz库不仅提供了当前的时区数据，还包含了历史上不同时期的时区信息，这使得它在处理历史数据时具有无与伦比的优势。 夏令时处理：pytz库能够自动处理夏令时的变化，当获取某个时区的时间时，它会自动考虑是否处于夏令时期间。 与datetime模块集成：pytz库可以与Python标准库中的datetime模块一起使用，以确保在涉及不同时区的场景中时间的准确性。
yolo算法-自行车数据集-3914张图像带标签-自行车.zip
11-03
yolo系列算法目标检测数据集，包含标签，可以直接训练模型和验证测试，数据集已经划分好，包含数据集配置文件data.yaml，适用yolov5,yolov8,yolov9,yolov7,yolov10,yolo11算法； 包含两种标签格:yolo格式（txt文件）和voc格式（xml文件），分别保存在两个文件夹中; yolo格式：<class> <x_center> <y_center> <width> <height>， 其中： <class> 是目标的类别索引（从0开始）。 <x_center> 和 <y_center> 是目标框中心点的x和y坐标，这些坐标是相对于图像宽度和高度的比例值，范围在0到1之间。 <width> 和 <height> 是目标框的宽度和高度，也是相对于图像宽度和高度的比例值
springboot053-某炼油厂盲板管理系统.zip
11-03
项目资源包含：可运行源码+sql文件 适用人群：学习不同技术领域的小白或进阶学习者；可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 项目具有较高的学习借鉴价值，也可拿来修改、二次开发。 有任何使用上的问题，欢迎随时与博主沟通，博主看到后会第一时间及时解答。 开发语言：Java 框架：springboot 技术：Vue JDK版本：JDK1.8 服务器：tomcat7 数据库：mysql 5.7（一定要5.7版本） 数据库工具：Navicat11 开发软件：eclipse/myeclipse/idea Maven包：Maven3.3.9 系统是一个很好的项目，结合了后端服务（SpringBoot）和前端用户界面（Vue.js）技术，实现了前后端分离。 后台路径地址：localhost:8080/项目名称/admin/dist/index.html 前台路径地址：localhost:8080/项目名称/front/index.html
NOIP树链剖分详解与实现
一、树链剖分的相关概念 1. 剖分目的：树链剖分的目的是为了高效地处理树结构中的路径信息，通过将树转化为链状结构，便于快速访问和更新路径上的节点。 2. 轻边与重边：在树链剖分中，边被分为两类——轻边和重边。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值