YBTOJ LCA问题合集

日常广告

树上距离

模板略。

货车运输

$n$ 个点 $m$ 条边，肯定有一些边是用不上的，kruskal建最大生成树，然后倍增LCA顺便维护一下路径上最小值就好了。

很模板，但是lca函数里不要忘了最后一步也要更新最小值。

int mi[N][25],f[N][25],dep[N];
inline void dfs(int x,int fa){
	f[x][0]=fa,dep[x]=dep[fa]+1;
	if(fa>n) mi[x][0]=1e9;
	ff(i,1,20) f[x][i]=f[f[x][i-1]][i-1],mi[x][i]=min(mi[x][i-1],mi[f[x][i-1]][i-1]);
	for(int i=head[x];i;i=e[i].nxt){
		int v=e[i].v,w=e[i].w;
		if(v==fa) continue;
		mi[v][0]=w;
		dfs(v,x);
	}
}
inline int lca(int x,int y){
	if(dep[x]<dep[y]) swap(x,y);
	int ans=1e9;
	for(int i=20;i>=0;--i) if(dep[f[x][i]]>=dep[y]) ans=min(ans,mi[x][i]),x=f[x][i];
	if(x==y) return ans;
	for(int i=20;i>=0;--i){
		if(f[x][i]!=f[y][i]){
			ans=min(ans,mi[x][i]),x=f[x][i];
			ans=min(ans,mi[y][i]),y=f[y][i];
		}
	}
	return min(ans,min(mi[x][0],mi[y][0]));
}

运输计划

最大值最小，首先想到二分答案，在不使用虫洞之前，每条航道的时间都是可以LCA预处理的，那么就只需要思考当前二分到的答案 $lim$ 怎么判断合法就好。

使用虫洞的边必然要被所有时间大于 $lim$ 的航道经过，考虑进行树上差分，$x$ 到 $y$ 的路径就在 $x$ 和 $y$ 处答案分别加一，在LCA处答案减2即可，那么差分相加一下就很好判断每条边被经过几次了，如果存在一条被所有不合法航道经过的边，使得减去它的权值后所有航道均合法，那么当前二分到的答案合法。

#include<bits/stdc++.h>
#define ll long long
#define ff(i,s,e) for(int i(s);i<=(e);++i)
using namespace std;
inline int read(){
	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<<1)+(x<<3)+(ch^48);ch=getchar();}
	return x*f;
}
const int N=3e5+5;
int n,m;
int head[N],cnt;
struct qwq{
	int v,w,nxt;
}e[N<<1];
inline void add(int u,int v,int w){
	e[++cnt]=qwq{v,w,head[u]},head[u]=cnt;
}
int f[N][22],dep[N],dis[N],val[N];
inline void dfs(int x,int fa){
	dep[x]=dep[fa]+1,f[x][0]=fa;
	ff(i,1,20) f[x][i]=f[f[x][i-1]][i-1];
	for(int i=head[x];i;i=e[i].nxt){
		int v=e[i].v;
		if(v==fa) continue;
		dis[v]=dis[x]+e[i].w,val[v]=e[i].w;
		dfs(v,x);
	}
}
struct qaq{
	int x,y,zz,w;
}a[N];
inline int lca(int x,int y){
	if(dep[x]<dep[y]) swap(x,y);
	for(int i=20;i>=0;--i) if(dep[f[x][i]]>=dep[y]) x=f[x][i];
	if(x==y) return x;
	for(int i=20;i>=0;--i)
		if(f[x][i]!=f[y][i]) x=f[x][i],y=f[y][i]; 
	return f[x][0];
}
int bj[N];
inline void dfss(int x,int fa){
	for(int i=head[x];i;i=e[i].nxt){
		int v=e[i].v;
		if(v==fa) continue;
		dfss(v,x);
		bj[x]+=bj[v];
	}
}
inline bool check(int lim){
	int maxx=0,num=0;
	ff(i,1,n) bj[i]=0;
	ff(i,1,m){
		if(a[i].w>lim){
			++num,maxx=max(maxx,a[i].w-lim);
			bj[a[i].x]++,bj[a[i].y]++,bj[a[i].zz]-=2;
		}
	}
	dfss(1,0);
	ff(i,1,n) if(bj[i]>=num&&val[i]>=maxx) return 1;
	return 0;
}
signed main(){
	n=read(),m=read();
	int l=0,r=0,ans;
	ff(i,2,n){
		int u=read(),v=read(),w=read();
		r+=w;
		add(u,v,w),add(v,u,w); 
	}
	dfs(1,0);
	ff(i,1,m){
		a[i].x=read(),a[i].y=read();
		a[i].zz=lca(a[i].x,a[i].y);
		a[i].w=dis[a[i].x]+dis[a[i].y]-(dis[a[i].zz]<<1);
	}
	while(l<=r){
		int mid=l+r>>1;
		if(check(mid)) ans=mid,r=mid-1;
		else l=mid+1;
	}
	printf("%d",ans);
	return 0;
}

次小生成树

最小生成树基础上加一条边，会形成一个环，再从环上删一条边。

考虑枚举加哪个边，若当前加 $x->y$ 之间的边，则要在最小生成树上 $x$ 到 $y$ 的路径中选一条最长的边删掉。于是可以维护最大值。

但是本题要求严格次小生成树，有可能删掉的边和加的边长度相同，为了避免这种情况还需要再维护一个次大值。最大值和次大值均在预处理LCA的时候同样倍增求即可。

那么枚举加边的时候只需要先求LCA，再分别倍增求一下 $x$ 和 $y$到LCA的路径最大值即可，注意最大值不能与当前加入的边权相同。（当然如果比较巨的话求LCA的时候顺便求答案也是可以的qwq

#include<bits/stdc++.h>
#define int long long
#define ff(i,s,e) for(int i(s);i<=(e);++i)
using namespace std;
inline int read(){
	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<<1)+(x<<3)+(ch^48);ch=getchar();}
	return x*f;
}
const int N=1e5+5,M=3e5+5;
int n,m;
int head[N],cnt;
struct qwq{
	int v,w,nxt;
}e[N<<1];
inline void add(int u,int v,int w){
	e[++cnt]=qwq{v,w,head[u]},head[u]=cnt;
}
struct qaq{
	int u,v,w;
}a[M];
int fa[N];
inline bool cmp(qaq x,qaq y){return x.w<y.w;}
inline int getf(int x){
	if(fa[x]==x) return x;
	return fa[x]=getf(fa[x]);
}
bool vis[M];
int siz;
inline void kru(){
	sort(a+1,a+m+1,cmp);
	ff(i,1,n) fa[i]=i;
	int cnt=0;
	ff(i,1,m){
		int u=a[i].u,v=a[i].v,w=a[i].w;
		int fu=getf(u),fv=getf(v);
		if(fu==fv) continue;
		fa[fu]=fv,++cnt,vis[i]=1,siz+=w;
		add(u,v,w),add(v,u,w);
		if(cnt==n-1) break;
	}
}
int dep[N],f[N][22],g[N][22],h[N][22];
inline void dfs(int x,int fa,int prew){
	dep[x]=dep[fa]+1;
	f[x][0]=fa,g[x][0]=prew,h[x][0]=-1e9;
	ff(i,1,20){
		f[x][i]=f[f[x][i-1]][i-1];
		g[x][i]=max(g[x][i-1],g[f[x][i-1]][i-1]);
		h[x][i]=max(h[x][i-1],h[f[x][i-1]][i-1]);
		if(g[x][i-1]>g[f[x][i-1]][i-1]) h[x][i]=max(h[x][i],g[f[x][i-1]][i-1]);
		else if(g[x][i-1]<g[f[x][i-1]][i-1]) h[x][i]=max(h[x][i],g[x][i-1]);
	}
	for(int i=head[x];i;i=e[i].nxt){
		int v=e[i].v,w=e[i].w;
		if(v==fa) continue;
		dfs(v,x,w);
	}
}
inline int lca(int x,int y){
	if(dep[x]<dep[y]) swap(x,y);
	for(int i=20;i>=0;--i) if(dep[f[x][i]]>=dep[y]) x=f[x][i];
	if(x==y) return x;
	for(int i=20;i>=0;--i){
		if(f[x][i]!=f[y][i]) x=f[x][i],y=f[y][i];
	}
	return f[x][0];
}
inline int get(int x,int zz,int lim){
	int ans=-1e9;
	for(int i=20;i>=0;--i){
		if(dep[f[x][i]]>=dep[zz]){
			if(lim!=g[x][i]) ans=max(ans,g[x][i]);
			else ans=max(ans,h[x][i]);
			x=f[x][i];
		}
	}
	return ans;
}
signed main(){
	n=read(),m=read();
	ff(i,1,m) a[i].u=read(),a[i].v=read(),a[i].w=read();
	kru();
	dfs(1,0,0);
	int ans=1e17;
	ff(i,1,m){
		if(vis[i]) continue;
		int u=a[i].u,v=a[i].v,zz=lca(u,v),w=a[i].w;
		int maxu=get(u,zz,w),maxv=get(v,zz,w);
		ans=min(ans,siz+w-max(maxu,maxv));
	}
	printf("%lld",ans);
	return 0;
}

祖孙询问

模板略++。

删边操作

留坑代填qwq

upd：删边改为加边，那么每次合并两棵树的新答案即原来答案 $÷$ 原第一棵树直径 $÷$ 原第二棵树直径 $\times$ 新树直径，两个除法操作直径用费马小定理求逆元，新树直径的两端点必定是来两棵树的直径端点，于是枚举 $C_4^2$ 种组合求出新直径即可。合并后两点之间距离一定等于最终树上两点之间距离，所以预处理最终的树，LCA求距离就是当前距离。

因为各种奇怪手残debug一小时也没谁了/kk

#include<bits/stdc++.h>
#define ll long long
#define ff(i,s,e) for(int i=s;i<=(e);++i)
using namespace std;
inline int read(){
	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<<1)+(x<<3)+(ch^48);ch=getchar();}
	return x*f;
}
const int N=1e5+5;
const int mod=1e9+7;
int n,a[N];
int head[N],cnt;
struct qwq{
	int v,nxt;
}e[N<<1];
inline void add(int u,int v){
	e[++cnt]=(qwq){v,head[u]},head[u]=cnt;
}
int x[N],y[N],num[N],ans[N];
int dep[N],f[N][22],dis[N];
inline void dfs(int x,int fa){
	dep[x]=dep[fa]+1,f[x][0]=fa,dis[x]+=a[x];
	ff(i,1,20) f[x][i]=f[f[x][i-1]][i-1];
	for(int i=head[x];i;i=e[i].nxt){
		int v=e[i].v;
		if(v==fa) continue;
		dis[v]+=dis[x];
		dfs(v,x);
	}
}
inline int lca(int x,int y){
	if(dep[x]<dep[y]) swap(x,y);
	for(int i=20;i>=0;--i) if(dep[f[x][i]]>=dep[y]) x=f[x][i];
	if(x==y) return x;
	for(int i=20;i>=0;--i) 
		if(f[x][i]!=f[y][i])
			x=f[x][i],y=f[y][i];
	return f[x][0];
}
inline int get(int x,int y){
	int zz=lca(x,y);
	return dis[x]+dis[y]-(dis[zz]<<1)+a[zz];
}
int fa[N],zj[N][2];
inline int getf(int x){
	if(x==fa[x]) return x;
	return fa[x]=getf(fa[x]);
}
inline int ksm(int x,int y){
	int res=1;
	for(;y;y>>=1){
		if(y&1) res=1ll*res*x%mod;
		x=1ll*x*x%mod;
	}
	return res;
}
signed main(){
	n=read();
	ff(i,1,n) ans[i]=1; 
	ff(i,1,n) a[i]=read(),fa[i]=i,ans[1]=1ll*ans[1]*a[i]%mod;
	ff(i,1,n-1){
		x[i]=read(),y[i]=read();
		zj[i][0]=zj[i][1]=i;
		add(x[i],y[i]),add(y[i],x[i]);
	}
	zj[n][0]=zj[n][1]=n;//不要忘了啊啊啊啊 
	for(int i=n;i>=2;--i) num[i]=read();
	dfs(1,0);
	ff(i,2,n){
		ans[i]=ans[i-1];
		int u=x[num[i]],v=y[num[i]],fu=getf(u),fv=getf(v);
		int d1=get(zj[fu][0],zj[fu][1]),d2=get(zj[fv][0],zj[fv][1]);
		int inv=ksm(1ll*d1*d2%mod,mod-2);
		int d=0,qaq[]={zj[fu][0],zj[fu][1],zj[fv][0],zj[fv][1]};
		int p1,p2;
		ff(j,0,2) ff(k,j+1,3){
			int now=get(qaq[j],qaq[k]);
			if(now>d) d=now,p1=qaq[j],p2=qaq[k];
		}
		fa[getf(fu)]=getf(fv),zj[fa[fu]][0]=p1,zj[fa[fu]][1]=p2;
		ans[i]=1ll*ans[i]*d%mod*inv%mod;
	}
	for(int i=n;i>=1;--i) printf("%d\n",ans[i]);
	return 0;
}