【Learning】倍增求LCA题目汇总

最新推荐文章于 2022-07-15 22:16:27 发布
最新推荐文章于 2022-07-15 22:16:27 发布
阅读量1.5k 收藏 3
点赞数
文章标签： 倍增
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ez_2016gdgzoi471/article/details/78691585
版权

这里是我倍增的练习记录，大多都是水题…也有一些混合了其它算法的。= = 顺序可能有些错乱，并不是按照难度来排的。
T1 hdu3710 倍增+树剖
这里写图片描述

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
using namespace std;
const int N=20005,M=100005,inf=2139062143;
int t,n,m,u,v,d,f,ns,rt,cnt,idx,head[N],to[N*2],nxt[N*2];
int dep[N],fa[N][20],siz[N],son[N],dfn[N],pos[N],top[N];
int minn[N],minv[N*4],tag[N*4];
bool use[M];
int s,mst,smst,pa[N],w[N],sont[N],num[N];
struct edge{
	int u,v,d;
	bool operator < (const edge &x)const{
		return d<x.d;
	}
}e[M];
vector<edge> link[N],edges;
void init(){
	smst=idx=cnt=rt=0;
	memset(use,0,sizeof(use));
	memset(head,0,sizeof(head));
	memset(dep,0,sizeof(dep));
	memset(fa,0,sizeof(fa));
	memset(son,0,sizeof(son));
	memset(sont,0,sizeof(sont));
	memset(w,0,sizeof(w));
	memset(minv,127,sizeof(minv));
	memset(tag,127,sizeof(tag));
	for(int i=1;i<=n;i++){
		pa[i]=i;
		link[i].clear();
	}
}
void adde(int u,int v){
	to[++cnt]=v;
	nxt[cnt]=head[u];
	head[u]=cnt;
}
int find(int u){
	return u==pa[u]?u:pa[u]=find(pa[u]);
}
void dfs(int u){
	for(int i=1;(1<<i)<=dep[u];i++){
		fa[u][i]=fa[fa[u][i-1]][i-1];
	}
	siz[u]=1;
	int v;
	for(int i=head[u];i;i=nxt[i]){
		v=to[i];
		if(v!=fa[u][0]){
			fa[v][0]=u;
			dep[v]=dep[u]+1;
			num[v]=++sont[u];
			dfs(v);
			siz[u]+=siz[v];
			if(!son[u]||siz[son[u]]<siz[v]){
				son[u]=v;
			}
		}
	}
}
void dfs(int u,int tp){
	dfn[u]=++idx;
	pos[idx]=u;
	top[u]=tp;
	if(son[u]){
		dfs(son[u],tp);
	}
	int v;
	for(int i=head[u];i;i=nxt[i]){
		v=to[i];
		if(v!=fa[u][0]&&v!=son[u]){
			dfs(v,v);
		}
	}
}
void pushdown(int o){
	minv[o*2]=min(minv[o*2],tag[o]);
	minv[o*2+1]=min(minv[o*2+1],tag[o]);
	tag[o*2]=min(tag[o*2],tag[o]);
	tag[o*2+1]=min(tag[o*2+1],tag[o]);
	tag[o]=inf;
}
void upd(int o,int l,int r,int L,int R,int x){
	if(L<=l&&R>=r){
		minv[o]=min(minv[o],x);
		tag[o]=min(tag[o],x);
		return;
	}
	if(tag[o]!=inf){
		pushdown(o);
	}
	int mid=(l+r)/2;
	if(L<=mid){
		upd(o*2,l,mid,L,R,x);
	}
	if(R>mid){
		upd(o*2+1,mid+1,r,L,R,x);
	}
	minv[o]=min(minv[o*2],minv[o*2+1]);
}
void update(int u,int v,int x){
	while(top[u]!=top[v]){
		upd(1,1,n,dfn[top[u]],dfn[u],x);
		u=fa[top[u]][0];
	}
	upd(1,1,n,dfn[v],dfn[u],x);
}
void getmin(int o,int l,int r){
	if(l==r){
		minn[pos[l]]=minv[o];
		return;
	}
	if(tag[o]!=inf){
		pushdown(o);
	}
	int mid=(l+r)/2;
	getmin(o*2,l,mid);
	getmin(o*2+1,mid+1,r);
}
void work(edge &e){
	int u=e.u,v=e.v,d;
	d=dep[u]-dep[v];
	for(int i=0;(1<<i)<=d;i++){
		if(d&(1<<i)){
			u=fa[u][i];
		}
	}
	if(u==v){
		u=e.u;
		d=dep[u]-dep[v]-2;
		if(d<0){
			return;
		}
		for(int i=0;(1<<i)<=d;i++){
			if(d&(1<<i)){
				u=fa[u][i];
			}
		}
		update(e.u,u,e.d);
		return;
	}
	int tmpu=u,tmpv=v;
	for(int i=15;i>=0;i--){
		if(fa[tmpu][i]!=fa[tmpv][i]){
			tmpu=fa[tmpu][i];
			tmpv=fa[tmpv][i];
		}
	}
	link[fa[tmpu][0]].push_back((edge){tmpu,tmpv,e.d});
	d=dep[e.u]-dep[tmpu]-1;
	if(d>=0){
		u=e.u;
		for(int i=0;(1<<i)<=d;i++){
			if(d&(1<<i)){
				u=fa[u][i];
			}
		}
		update(e.u,u,e.d);
	}
	d=dep[e.v]-dep[tmpv]-1;
	if(d>=0){
		v=e.v;
		for(int i=0;(1<<i)<=d;i++){
			if(d&(1<<i)){
				v=fa[v][i];
			}
		}
		update(e.v,v,e.d);
	}
}
int main(){
	scanf("%d",&t);
	while(t--){
		scanf("%d%d",&n,&m);
		init();
		for(int i=1;i<=m;i++){
			scanf("%d%d%d%d",&e[i].u,&e[i].v,&d,&f);
			e[i].d=d*(1-f);
		}
		sort(e+1,e+m+1);
		ns=0;
		for(int i=1;i<=m&&ns<n-1;i++){
			u=find(e[i].u),v=find(e[i].v);
			if(u!=v){
				use[i]=true;
				pa[v]=u;
				ns++;
				adde(e[i].u,e[i].v);
				adde(e[i].v,e[i].u);
				w[e[i].u]+=e[i].d;
				w[e[i].v]+=e[i].d;
				smst+=e[i].d;
				if(!rt){
					rt=e[i].u;
				}
			}
		}
		dfs(rt);
		dfs(rt,rt);
		for(int i=1;i<=m;i++){
			if(!use[i]){
				if(dep[e[i].u]<dep[e[i].v]){
					swap(e[i].u,e[i].v);
				}
				work(e[i]);
			}
		}
		getmin(1,1,n);
		for(int i=1;i<=n;i++){
			edges.clear();
			s=sont[i];
			if(fa[i][0]){
				s++;
				for(int j=head[i];j;j=nxt[j]){
					v=to[j];
					if(v!=fa[i][0]&&minn[v]!=inf){
						edges.push_back((edge){num[v],s,minn[v]});
					}
				}
			}
			for(int j=0;j<link[i].size();j++){
				edges.push_back((edge){num[link[i][j].u],num[link[i][j].v],link[i][j].d});
			}
			sort(edges.begin(),edges.end());
			mst=0;
			for(int j=1;j<=s;j++){
				pa[j]=j;
			}
			ns=0;
			for(int j=0;j<edges.size()&&ns<s-1;j++){
				u=find(edges[j].u),v=find(edges[j].v);
				if(u!=v){
					pa[v]=u;
					ns++;
					mst+=edges[j].d;
				}
			}
			if(ns<s-1){
				puts("inf");
			}else{
				printf("%d\n",smst-w[i]+mst);
			}
		}
	}
	return 0;
}

T2 luogu3379 模板题
这里写图片描述

#include<cstdio>
#include<algorithm>
using namespace std;
int n,m,root,cnt,u,v,head[500005],to[1000005],nxt[1000005],dep[500005],fa[500005][21];
void adde(int u,int v){
	to[++cnt]=v;
	nxt[cnt]=head[u];
	head[u]=cnt;
}
void dfs(int u){
	for(int i=1;(1<<i)<=dep[u];i++){
		fa[u][i]=fa[fa[u][i-1]][i-1];
	}
	int v;
	for(int i=head[u];i;i=nxt[i]){
		v=to[i];
		if(v!=fa[u][0]){
			fa[v][0]=u;
			dep[v]=dep[u]+1;
			dfs(v);
		}
	}
}
int lca(int u,int v){
	if(dep[u]<dep[v]){
		swap(u,v);
	}
	int d=dep[u]-dep[v];
	for(int i=0;(1<<i)<=d;i++){
		if(d&(1<<i)){
			u=fa[u][i];
		}
	}
	if(u==v){
		return u;
	}
	for(int i=20;i>=0;i--){
		if(fa[u][i]!=fa[v][i]){
			u=fa[u][i];
			v=fa[v][i];
		}
	}
	return fa[u][0];
}
int main(){
	scanf("%d%d%d",&n,&m,&root);
	for(int i=1;i<n;i++){
		scanf("%d%d",&u,&v);
		adde(u,v);
		adde(v,u);
	}
	dfs(root);
	while(m--){
		scanf("%d%d",&u,&v);
		printf("%d\n",lca(u,v));
	}
	return 0;
}

T3 zoj3195 模板题
这里写图片描述

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int n,q,cnt,u,v,d,head[50005],to[100005],nxt[100005],dep[50005],dis[50005],dd[100005],fa[50005][21];
bool flag=false; 
void adde(int u,int v,int d){
	to[++cnt]=v;
	nxt[cnt]=head[u];
	dd[cnt]=d;
	head[u]=cnt;
}
void dfs(int u){
	for(int i=1;(1<<i)<=dep[u];i++){
		fa[u][i]=fa[fa[u][i-1]][i-1];
	}
	int v;
	for(int i=head[u];i;i=nxt[i]){
		v=to[i];
		if(v!=fa[u][0]){
			fa[v][0]=u;
			dep[v]=dep[u]+1;
			dis[v]=dis[u]+dd[i];
			dfs(v);
		}
	}
}
int lca(int u,int v){
	if(dep[u]<dep[v]){
		swap(u,v);
	}
	int d=dep[u]-dep[v];
	for(int i=0;(1<<i)<=d;i++){
		if(d&(1<<i)){
			u=fa[u][i];
		}
	}
	if(u==v){
		return u;
	}
	for(int i=20;i>=0;i--){
		if(fa[u][i]!=fa[v][i]){
			u=fa[u][i];
			v=fa[v][i];
		}
	}
	return fa[u][0];
}
int main(){
	while(~scanf("%d",&n)){
		if(!flag){
			flag=true;
		}else{
			puts("");
		}
		cnt=0;
		memset(head,0,sizeof(head));
		memset(dep,0,sizeof(dep));
		memset(fa,0,sizeof(fa));
		memset(dis,0,sizeof(dis)); 
		for(int i=1;i<n;i++){
			scanf("%d%d%d",&u,&v,&d);
			u++,v++;
			adde(u,v,d);
			adde(v,u,d);
		}
		dfs(1);
		scanf("%d",&q);
		for(int i=1;i<=q;i++){
			scanf("%d%d%d",&u,&v,&d);
			u++,v++,d++;
			printf("%d\n",dis[u]+dis[v]+dis[d]-dis[lca(u,v)]-dis[lca(u,d)]-dis[lca(v,d)]);
		}
	}
	return 0;
}

T4 bzoj2588 主席树+树上差分+倍增lca
这里写图片描述

#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
const int N=100005;
int n,m,x,y,k,lca,lastans=0,tot=0,cnt=0,a[N],head[N],nxt[N*2],to[N*2],root[N],dep[N],fa[N][20];
vector<int> v;
struct Node
{
	int l,r,sum;
	Node(){sum=0;}
}node[N*40];
int getId(int x)
{
	return lower_bound(v.begin(),v.end(),x)-v.begin()+1;
}
void adde(int u,int v)
{
	to[++tot]=v;
	nxt[tot]=head[u];
	head[u]=tot;
}
void update(int l,int r,int &x,int y,int pos)
{
	node[x=++cnt]=node[y];
	node[x].sum++;
	if(l==r) return;
	int mid=(l+r)/2;
	if(pos<=mid) update(l,mid,node[x].l,node[y].l,pos);
	else update(mid+1,r,node[x].r,node[y].r,pos);
}
int query(int l,int r,int a,int b,int c,int d,int k)
{
	if(l==r) return l;
	int mid=(l+r)/2,sum=node[node[a].l].sum+node[node[b].l].sum-node[node[c].l].sum-node[node[d].l].sum;
	if(k<=sum) return query(l,mid,node[a].l,node[b].l,node[c].l,node[d].l,k);
	else return query(mid+1,r,node[a].r,node[b].r,node[c].r,node[d].r,k-sum);
}
void dfs(int pre,int u,int d)
{
	fa[u][0]=pre;
	dep[u]=d;
	for(int i=1;(1<<i)<=d;i++)
		fa[u][i]=fa[fa[u][i-1]][i-1];
	update(1,n,root[u],root[pre],getId(a[u]));
	for(int i=head[u];i;i=nxt[i])
		if(to[i]^pre)
			dfs(u,to[i],d+1);
}
int LCA(int u,int v)
{
	if(dep[u]>dep[v]) swap(u,v);
	int d=dep[v]-dep[u];
	for(int i=0;(1<<i)<=d;i++)
		if((1<<i)&d) v=fa[v][i];
	if(u!=v)
	{
		for(int i=16;i>=0;i--)
			if(fa[u][i]!=fa[v][i])
			{
				u=fa[u][i];
				v=fa[v][i];
			}
		u=fa[u][0];
	}
	return u;
}
int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&a[i]);
		v.push_back(a[i]);
	}
	sort(v.begin(),v.end());
	v.erase(unique(v.begin(),v.end()),v.end());
	for(int i=1;i<n;i++)
	{
		scanf("%d%d",&x,&y);
		adde(x,y);
		adde(y,x);
	}
	dfs(0,1,1);
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d%d",&x,&y,&k);
		x^=lastans;
		lca=LCA(x,y);
		lastans=v[query(1,n,root[x],root[y],root[lca],root[fa[lca][0]],k)-1];
		printf("%d",lastans);
		if(i^m) putchar('\n');
	}
	return 0;
}

T5 bzoj1787&&bzoj1832 模版题
这里写图片描述
这里写图片描述

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int t,n,q,cnt,u,v,d,t1,t2,t3,p,head[500005],to[1000005],nxt[1000005],dep[500005],fa[500005][21];
void adde(int u,int v){
	to[++cnt]=v;
	nxt[cnt]=head[u];
	head[u]=cnt;
}
void dfs(int u){
	for(int i=1;(1<<i)<=dep[u];i++){
		fa[u][i]=fa[fa[u][i-1]][i-1];
	}
	int v;
	for(int i=head[u];i;i=nxt[i]){
		v=to[i];
		if(v!=fa[u][0]){
			fa[v][0]=u;
			dep[v]=dep[u]+1;
			dfs(v);
		}
	}
}
int lca(int u,int v){
	if(dep[u]<dep[v]){
		swap(u,v);
	}
	int d=dep[u]-dep[v];
	for(int i=0;(1<<i)<=d;i++){
		if(d&(1<<i)){
			u=fa[u][i];
		}
	}
	if(u==v){
		return u;
	}
	for(int i=20;i>=0;i--){
		if(fa[u][i]!=fa[v][i]){
			u=fa[u][i];
			v=fa[v][i];
		}
	}
	return fa[u][0];
}
int dis(int u,int v){
	return dep[u]+dep[v]-2*dep[lca(u,v)]; 
}
int main(){
	scanf("%d%d",&n,&q);
	for(int i=1;i<n;i++){
		scanf("%d%d",&u,&v);
		adde(u,v);
		adde(v,u);
	}
	dfs(1);
	for(int i=1;i<=q;i++){
		scanf("%d%d%d",&u,&v,&d);
		t1=lca(u,v),t2=lca(u,d),t3=lca(v,d);
		if(t1==t2){
			p=t3;
		}
		else if(t1==t3){
			p=t2;
		}
		else{
			p=t1;
		}
		printf("%d %d\n",p,dis(u,p)+dis(v,p)+dis(d,p));
	}
	return 0;
}

T6 hdu2586 模版题
这里写图片描述

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int t,n,q,cnt,u,v,d,head[40005],to[80005],nxt[80005],dep[40005],dis[40005],dd[800005],fa[40005][21];
void adde(int u,int v,int d){
	to[++cnt]=v;
	nxt[cnt]=head[u];
	dd[cnt]=d;
	head[u]=cnt;
}
void dfs(int u){
	for(int i=1;(1<<i)<=dep[u];i++){
		fa[u][i]=fa[fa[u][i-1]][i-1];
	}
	int v;
	for(int i=head[u];i;i=nxt[i]){
		v=to[i];
		if(v!=fa[u][0]){
			fa[v][0]=u;
			dep[v]=dep[u]+1;
			dis[v]=dis[u]+dd[i];
			dfs(v);
		}
	}
}
int lca(int u,int v){
	if(dep[u]<dep[v]){
		swap(u,v);
	}
	int d=dep[u]-dep[v];
	for(int i=0;(1<<i)<=d;i++){
		if(d&(1<<i)){
			u=fa[u][i];
		}
	}
	if(u==v){
		return u;
	}
	for(int i=20;i>=0;i--){
		if(fa[u][i]!=fa[v][i]){
			u=fa[u][i];
			v=fa[v][i];
		}
	}
	return fa[u][0];
}
int main(){
	scanf("%d",&t);
	while(t--){
		scanf("%d%d",&n,&q);
		cnt=0;
		memset(head,0,sizeof(head));
		memset(dep,0,sizeof(dep));
		memset(fa,0,sizeof(fa));
		memset(dis,0,sizeof(dis)); 
		for(int i=1;i<n;i++){
			scanf("%d%d%d",&u,&v,&d);
			adde(u,v,d);
			adde(v,u,d);
		}
		dfs(1);
		for(int i=1;i<=q;i++){
			scanf("%d%d",&u,&v);
			printf("%d\n",dis[u]+dis[v]-2*dis[lca(u,v)]);
		}
	}
	return 0;
}

T7 poj1330 模版题
这里写图片描述

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int t,n,cnt,u,v,head[10005],to[10005],nxt[10005],dep[10005],fa[10005][21];
bool ck[10005];
void adde(int u,int v){
	to[++cnt]=v;
	nxt[cnt]=head[u];
	head[u]=cnt;
}
void dfs(int u){
	for(int i=1;(1<<i)<=dep[u];i++){
		fa[u][i]=fa[fa[u][i-1]][i-1];
	}
	int v;
	for(int i=head[u];i;i=nxt[i]){
		v=to[i];
		fa[v][0]=u;
		dep[v]=dep[u]+1;
		dfs(v);
	}
}
int lca(int u,int v){
	if(dep[u]<dep[v]){
		swap(u,v);
	}
	int d=dep[u]-dep[v];
	for(int i=0;(1<<i)<=d;i++){
		if(d&(1<<i)){
			u=fa[u][i];
		}
	}
	if(u==v){
		return u;
	}
	for(int i=20;i>=0;i--){
		if(fa[u][i]!=fa[v][i]){
			u=fa[u][i];
			v=fa[v][i];
		}
	}
	return fa[u][0];
}
int main(){
	scanf("%d",&t);
	while(t--){
		scanf("%d",&n);
		cnt=0;
		memset(head,0,sizeof(head));
		memset(dep,0,sizeof(dep));
		memset(fa,0,sizeof(fa));
		memset(ck,0,sizeof(ck));
		for(int i=1;i<n;i++){
			scanf("%d%d",&u,&v);
			adde(u,v);
			ck[v]=true;
		}
		for(int i=1;i<=n;i++){
			if(!ck[i]){
				dfs(i);
				break;
			}
		}
		scanf("%d%d",&u,&v);
		printf("%d\n",lca(u,v));
	}
	return 0;
}

T8 gdgzoi2232祖孙询问 模版题
这里写图片描述

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int t,n,m,cnt,u,v,tmp,rt,head[40005],to[80005],nxt[80005],dep[40005],fa[40005][21];
void adde(int u,int v){
	to[++cnt]=v;
	nxt[cnt]=head[u];
	head[u]=cnt;
}
void dfs(int u){
	for(int i=1;(1<<i)<=dep[u];i++){
		fa[u][i]=fa[fa[u][i-1]][i-1];
	}
	int v;
	for(int i=head[u];i;i=nxt[i]){
		v=to[i];
		if(v!=fa[u][0]){
			fa[v][0]=u;
			dep[v]=dep[u]+1;
			dfs(v);
		}
	}
}
int lca(int u,int v){
	if(dep[u]<dep[v]){
		swap(u,v);
	}
	int d=dep[u]-dep[v];
	for(int i=0;(1<<i)<=d;i++){
		if(d&(1<<i)){
			u=fa[u][i];
		}
	}
	if(u==v){
		return u;
	}
	for(int i=20;i>=0;i--){
		if(fa[u][i]!=fa[v][i]){
			u=fa[u][i];
			v=fa[v][i];
		}
	}
	return fa[u][0];
}
int main(){
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		scanf("%d%d",&u,&v);
		if(~v){
			adde(u,v);
			adde(v,u);
		}
		else{
			rt=u;
		}
	}
	dfs(rt);
	scanf("%d",&m);
	for(int i=1;i<=m;i++){
		scanf("%d%d",&u,&v);
		tmp=lca(u,v);
		if(tmp==u){
			puts("1");
		}else if(tmp==v){
			puts("2");
		}else{
			puts("0");
		}
	}
	return 0;
}

这么多水题忽然好颓废啊！
T9 luogu1967&&xsy2018 倍增+最大生成树
这里写图片描述

#include<cstdio>
#include<algorithm>
using namespace std;
int n,m,q,u,v,cnt,pa[10005],head[10005],to[20005],nxt[20005],dd[20005],fa[10005][20],minn[10005][20];
int dep[10005];
struct edge{
	int u,v,d;
}e[50005];
bool cmp(edge a,edge b){
	return a.d>b.d;
}
int find(int u){
	return u==pa[u]?u:pa[u]=find(pa[u]);
}
void adde(int u,int v,int d){
	to[++cnt]=v;
	nxt[cnt]=head[u];
	dd[cnt]=d;
	head[u]=cnt;
}
void dfs(int u){
	for(int i=1;(1<<i)<=dep[u];i++){
		fa[u][i]=fa[fa[u][i-1]][i-1];
		minn[u][i]=min(minn[u][i-1],minn[fa[u][i-1]][i-1]);
	}
	int v;
	for(int i=head[u];i;i=nxt[i]){
		v=to[i];
		if(v!=fa[u][0]){
			fa[v][0]=u;
			minn[v][0]=dd[i];
			dep[v]=dep[u]+1;
			dfs(v);
		}
	}
}
int solve(int u,int v){
	if(dep[u]<dep[v]){
		swap(u,v);
	}
	int ans=0x7fffffff,d=dep[u]-dep[v];
	for(int i=0;(1<<i)<=d;i++){
		if(d&(1<<i)){
			ans=min(ans,minn[u][i]);
			u=fa[u][i];
		}
	}
	if(u==v){
		return ans;
	}
	for(int i=16;i>=0;i--){
		if(fa[u][i]!=fa[v][i]){
			ans=min(ans,min(minn[u][i],minn[v][i]));
			u=fa[u][i];
			v=fa[v][i];
		}
	}
	if(fa[u][0]){
		return min(ans,min(minn[u][0],minn[v][0]));
	}else{
		return -1;
	}
}
int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n;i++){
		pa[i]=i;
	}
	for(int i=1;i<=m;i++){
		scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].d);
	}
	sort(e+1,e+m+1,cmp);
	for(int i=1;i<=m;i++){
		u=find(e[i].u),v=find(e[i].v);
		if(u!=v){
			adde(e[i].u,e[i].v,e[i].d);
			adde(e[i].v,e[i].u,e[i].d);
			pa[v]=u;
		}
	}
	dfs(1);
	scanf("%d",&q);
	for(int i=1;i<=q;i++){
		scanf("%d%d",&u,&v);
		printf("%d\n",solve(u,v));
	}
	return 0;
}

T10 CF587C&&xsy2414 倍增+归并
这里写图片描述

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int n,m,q,u,v,t,tmp,cnt,ans[15],a[100005],head[100005],to[200005],nxt[200005],fa[100005][20],dep[100005],minn[100005][20][15];
void adde(int u,int v){
	to[++cnt]=v;
	nxt[cnt]=head[u];
	head[u]=cnt;
}
void merge(int a[],int b[],int d[]){
	int i=1,j=1,k=0,c[15];
	while(i<=a[0]&&j<=b[0]&&k<10){
		if(a[i]<b[j]){
			c[++k]=a[i++];
		}else{
			c[++k]=b[j++];
		}
	}
	while(i<=a[0]&&k<10){
		c[++k]=a[i++];
	}
	while(j<=b[0]&&k<10){
		c[++k]=b[j++];
	}
	for(int i=1;i<=k;i++){
		d[i]=c[i];
	}
	d[0]=k;
}
void dfs(int u){
	memcpy(minn[u][1],minn[fa[u][1]][0],sizeof(minn[fa[u][1]][0]));
	for(int i=2;i<=17;i++){
		fa[u][i]=fa[fa[u][i-1]][i-1];
		merge(minn[u][i-1],minn[fa[u][i-1]][i-1],minn[u][i]);
	}
	int v;
	for(int i=head[u];i;i=nxt[i]){
		v=to[i];
		if(v!=fa[u][1]){
			fa[v][1]=u;
			dep[v]=dep[u]+1;
			dfs(v);
		}
	}
} 
void solve(int u,int v,int t){
	if(dep[u]<dep[v]){
		swap(u,v);
	}
	int d=dep[u]-dep[v];
	memcpy(ans,minn[u][0],sizeof(minn[u][0]));
	for(int i=1;i<=17;i++){
		if(d&(1<<(i-1))){
			merge(ans,minn[u][i],ans);
			u=fa[u][i];
		}
	}
	if(u!=v){
		merge(ans,minn[v][0],ans);
		for(int i=17;i>=1;i--){
			if(fa[u][i]!=fa[v][i]){
				merge(ans,minn[u][i],ans);
				merge(ans,minn[v][i],ans);
				u=fa[u][i];
				v=fa[v][i];
			}
		}
		merge(ans,minn[u][1],ans);
	}
	ans[0]=min(ans[0],t);
	printf("%d ",ans[0]);
	for(int i=1;i<=ans[0];i++){
		printf("%d ",ans[i]);
	}
	puts("");
}
int main(){
	scanf("%d%d%d",&n,&m,&q);
	for(int i=1;i<n;i++){
		scanf("%d%d",&u,&v);
		adde(u,v);
		adde(v,u);
	}
	for(int i=1;i<=m;i++){
		scanf("%d",&tmp);
		minn[tmp][0][++minn[tmp][0][0]]=i;
	}
	dfs(1);
	for(int i=1;i<=q;i++){
		scanf("%d%d%d",&u,&v,&t);
		solve(u,v,t);
	}
	return 0;
}

T11 bzoj3545&&bzoj3551 并查集+谜之建树+倍增+线段树
UPD 2020.11.9：这是Kruskal重构树。
这里写图片描述
这里写图片描述

#include<cstdio>
#include<algorithm>
#include<vector>
using namespace std;
inline int rd()
{
	int x=0,f=1;char ch=getchar();
	while(ch>'9'||ch<'0'){if(ch=='-')f=-1;ch=getchar();}
	while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
const int N=100005;
int n,m,q,tot,cnt,idx,h[N],pa[2*N],val[2*N],head[N*2],to[N*2],nxt[N*2],dep[N*2],fa[N*2][20],mx[N*2][20];
int lc[50*N],rc[50*N],sumv[50*N],pos[N*3],root[N*3],bg[N*2],ed[N*2];
bool vis[N*2];
vector<int> V;
struct edge
{
	int u,v,d;
}a[5*N];
bool cmp(edge a,edge b)
{
	return a.d<b.d;
}
int findrt(int u)
{
	return u==pa[u]?u:pa[u]=findrt(pa[u]);
}
void adde(int u,int v)
{
	to[++cnt]=v;
	nxt[cnt]=head[u];
	head[u]=cnt;
}
void dfs(int u)
{
	vis[u]=true;
	pos[++pos[0]]=u;
	for(int i=1;(1<<i)<=dep[u];i++)
	{
		fa[u][i]=fa[fa[u][i-1]][i-1];
		mx[u][i]=max(mx[u][i-1],mx[fa[u][i-1]][i-1]);
	}
	for(int i=head[u];i;i=nxt[i])
	{
		dep[to[i]]=dep[u]+1;
		fa[to[i]][0]=u;
		mx[to[i]][0]=val[u];
		dfs(to[i]);
	}
	if(u>n) pos[++pos[0]]=u;
}
void update(int &x,int y,int l,int r,int k)
{
	x=++idx;
	sumv[x]=sumv[y]+1;
	lc[x]=lc[y];
	rc[x]=rc[y];
	if(l==r) return;
	int mid=(l+r)/2;
	if(k<=mid) update(lc[x],lc[y],l,mid,k);
	else update(rc[x],rc[y],mid+1,r,k);
}
int query(int x,int y,int l,int r,int k)
{
	if(l==r) return l;
	int mid=(l+r)/2,sum=sumv[lc[y]]-sumv[lc[x]];
	if(k<=sum) return query(lc[x],lc[y],l,mid,k);
	else return query(rc[x],rc[y],mid+1,r,k-sum);
}
void build()
{
	tot=n;
	sort(a+1,a+m+1,cmp);
	for(int i=1;i<=m;i++)
	{
		int p=findrt(a[i].u),q=findrt(a[i].v);
		if(p^q)
		{
			tot++;
			pa[p]=pa[q]=tot;
			val[tot]=a[i].d;
			adde(tot,p);
			adde(tot,q);
			if(tot==n*2-1) break;
		}
	}
	for(int i=1;i<=n;i++)
		if(!vis[i]) dfs(findrt(i));
	for(int i=1;i<=pos[0];i++)
	{
		int tmp=pos[i];
		if(tmp<=n) update(root[i],root[i-1],1,n,h[tmp]);
		else
		{
			root[i]=root[i-1];
			if(!bg[tmp]) bg[tmp]=i;
			else ed[tmp]=i;
		}
	}
}
int find(int x,int v)
{
	for(int i=17;i>=0;i--)
		if(dep[x]>=(1<<i)&&mx[x][i]<=v)
			x=fa[x][i];
	return x;
}
void solve()
{
	int ans=0,v,x,k;
	for(int i=1;i<=q;i++)
	{
		v=rd(),x=rd(),k=rd();
		if(ans!=-1) v^=ans,x^=ans,k^=ans;
		int t=find(v,x);
		int a=root[bg[t]],b=root[ed[t]];
		if(sumv[b]-sumv[a]<k) ans=-1;
		else ans=V[query(a,b,1,n,sumv[b]-sumv[a]-k+1)-1];
		printf("%d\n",ans);
	}
}
int main()
{
	n=rd(),m=rd(),q=rd();
	for(int i=1;i<=n;i++)
		V.push_back(h[i]=rd());
	sort(V.begin(),V.end());
	for(int i=1;i<=n;i++)
		h[i]=lower_bound(V.begin(),V.end(),h[i])-V.begin()+1;
	for(int i=1;i<=2*n;i++) pa[i]=i;
	for(int i=1;i<=m;i++)
		a[i].u=rd(),a[i].v=rd(),a[i].d=rd();
	build();
	solve();
	return 0;
}

终于写完了，好嗨森！

ez_2016gdgzoi471
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ST算法 - RMQ（区间最值问题）—— 倍增
Mr_dimple的博客
10-15 949
带你深入理解 ST算法 的本质——倍增。
【图论】LCA（倍增）
SY奇星的OI博客
07-27 2124
LCA通常指的是“最近共同祖先”（Lowest Common Ancestor）。LCA是一种用于解决树或图结构中两个节点的最低共同祖先的问题的算法。在树结构中，LCA是指两个节点的最近层级的共同祖先节点。例如，考虑一棵树，其中节点A是节点B和节点C的祖先，而节点D是节点B和节点C的共同祖先，但节点D不是最低层级的共同祖先。在这种情况下，LCA就是节点D。LCA算法在计算机科学中有广泛的应用，例如在计算树的最近公共祖先、解决图的连通性问题、计算有向无环图（DAG）的最近公共祖先等方面。
求LCA的四种方法（暴力，倍增，RMQ+ST，Tarjan）
春弦的博客
02-27 5306
P3379 【模板】最近公共祖先（LCA） #include<bits/stdc++.h> using namespace std; struct Edge { int to,next; }edge[500005*2];//无向图，两倍开 int head[500005],grand[500005][21],depth[500005],lg[500001]; int cnt,n,m,s; inline int read() { int x=0,f=1;char ch=getch.
LCA问题专题
R的博客
07-15 428
LCA的于各类题目中的应用
LCA & 用到LCA的各种题目
qq_35811331的博客
08-22 749
LCA求最近公共祖先LCA LCA 倍增实现快速求出树上两点的公共祖先，实现原理像是树上ST表，先预处理出来每个点的2^n的父亲是谁与它的深度，然后求lca时把两点先都跳到同一高度，如果重合为一个点，则这个点就是最近公共祖先，不然就倍增从大到小跳，直到跳到祖先的儿子节点，然后返回此时节点的父亲节点。 代码： #include <bits/stdc++.h> using namespac...
第4章 倍增求LCA 测试数据.rar
12-02
《第4章 倍增求LCA》的测试数据主要针对信息学竞赛中的一个重要算法问题——最近公共祖先（Lowest Common Ancestor, LCA）。在树形结构中，两个节点的最近公共祖先指的是在树中离这两个节点最近的一个共同祖先。在...
C++做倍增求LCA的模版
最新发布
04-14
模版，讲解量较少
Pascal LCA 倍增法详解及代码
10-08
本文介绍的是一种基于倍增法的在线算法，它能够以更高效的方式求解LCA。倍增法的思想是利用2的幂次快速跳跃，通过预先计算部分信息，使得在询问时可以快速找到最近公共祖先。具体实现中，我们定义函数f(u,k) = Fa(u,...
第4章 倍增求LCA-2019-12-05.pdf
12-05
第4章 倍增求LCA-2019-12-05 第4章 倍增求LCA-2019-12-05 第4章 倍增求LCA-2019-12-05
St表欧拉序倍增搞LCA.zip_LCA_lca st表_st表
09-25
本压缩包文件“St表欧拉序倍增搞LCA.zip”主要涉及如何利用St表（也称为线段树）高效地解决LCA查询问题。下面将详细介绍LCA、St表以及它们如何结合来实现高效的查询算法。 首先，让我们理解最近公共祖先(LCA)的概念...
倍增好题记录
weixin_30551963的博客
09-14 391
超级钢琴: [BZOJ 2006] [NOI 2010]超级钢琴(贪心+ST表+堆) 药不能停:[HDU 3712] Fiolki (带边权并查集+启发式合并) 监控: 类似"国旗计划”,不同的是要去掉被完全包含的区间 国旗计划:[BZOJ4444] [Luogu 4155] [LOJ 2007] [SCOI2015]国旗计划(倍增) 星际穿越:[Luogu 5465] [LOJ 643...
倍增例题AcWing109
7_26的博客
05-23 350
Genius ACM 给定一个整数 M，对于任意一个整数集合 S，定义“校验值”如下: 从集合 S 中取出 M 对数(即 2×M 个数，不能重复使用集合中的数，如果 S 中的整数不够 M 对，则取到不能取为止)，使得“每对数的差的平方”之和最大，这个最大值就称为集合 S 的“校验值”。 现在给定一个长度为 N 的数列 A 以及一个整数 T。 我们要把 A 分成若干段，使得每一段的“校验值”都不超过 T。 求最少需要分成几段。 输入格式 第一行输入整数 K，代表有 K 组测试数据。 对于每组测试数据，第一行包
LCA题集
自强不息 厚德载物
10-02 426
点的距离（模板题） 树中两点间的距离就是d[u] + d[v] - 2 * d[lca(u, v)] #include&lt;bits/stdc++.h&gt; #define REP(i, a, b) for(register int i = (a); i &lt; (b); i++) #define _for(i, a, b) for(register int i = (a); i &...
lca倍增算法学习记录
wangwangbu的博客
05-19 4950
找最近公共父节点这问题很容易想到让两节点一起往上走最后相遇，但这样的dfs显然很慢，于是就需要倍增。就是用二进制的思维，以1,2,4,8等2的阶层步长接近答案，比一步一步向上要快很多。 所以要dfs出来点的2^k的父亲节点与该节点的深度。 找lca时先将下面的点升到与另一点同一深度，再用往上倍增找lca。 有两种大同小异的方法：一种是以上一步2倍长的步伐向上试，不行再缩减，找到一个里lca能达
倍增算法
ccyf0606的博客
07-16 372
https://blog.csdn.net/lw277232240/article/details/72870644倍增实现lca https://blog.csdn.net/Hanks_o/article/details/77547380st表 https://blog.csdn.net/whistlena/article/details/52191463st表  ...
超级详细 倍增法 实现 LCA
热门推荐
旺旺的博客
06-05 2万+
描述：倍增法用于很多算法当中，通过字面意思来理解就是翻倍增加嘛，这里着重讲使用倍增法在树中的应用求LCA； LCA是啥呢  在一棵树当中 lca表示的是两个节点最近公共祖先， 大家看这课树哈节点5 ，3的lca就是1，13和11的LCA就是6。节点8,12的lca就是8，那么我们如何通过被增来实现LCA呢。 首先 大家看下这个数组 grand[x][i] ,这个数组表示标号为x节
树上差分与LCA(最近公共祖先)【题目与模板】
R的博客
03-03 205
树上差分与LCA
算法模板——倍增求LCA
Canopus
11-08 272
LCA是什么？ 最近公共祖先，就是树上的两个点它们深度最大（离根节点最远）的公共祖先。算法 1. 朴素算法。时间复杂度O(n×q)O(n\times q)。并没有实际意义。 2. 倍增算法。时间复杂度O((n+q)logn)O((n+q)\log n)。倍增算法 它的特点是：每次向祖先跳的距离，不是11，而是2k2^k，这样可以省很多时间。 记录每个点的fai,jfa_{i,j}，表示ii
lca入门———树上倍增法（博文内含例题）
keshuqi的博客
07-09 952
倍增求LCA： father【i】【j】表示节点i往上跳2^j次后的节点 可以转移为 father【i】【j】=father【father【i】【j-1】】【j-1】 整体思路： 先比较两个点的深度，如果深度不同，先让深的点往上跳，浅的先不动，等两个点深度一样时，if 相同 直接返回，if 不同 进行下一步；如果不同，两个点一起跳，j从大到小枚举（其实并不大），如果两个点都跳这么
Tarjan求LCA
07-27
- *2* *3* [详解使用 Tarjan 求 LCA 问题（图解）](https://blog.csdn.net/weixin_34315485/article/details/93801193)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值