浅析NOIP中的图论【2】

最新推荐文章于 2022-08-19 11:06:59 发布

ILoveDuyulin

最新推荐文章于 2022-08-19 11:06:59 发布

阅读量245

点赞数

文章标签： c++ 算法数据结构推荐算法深度优先

本文链接：https://blog.csdn.net/m0_59459037/article/details/120594037

版权

浅析NOIP中的图论【1】

3.LCA的综合运用

lca基础芝士

（1）树上差分

在序列中，我们定义其前缀和与差分序列，把区间的增减转化为左端点加1，右端点减1，根绝差分序列的前缀和是原序列这一原理，在树上也可以进行类似的简化，其中“区间操作”对应“路径操作”，“前缀和”对应“子树和”

经典模型：给定一张无向图和一棵生成树，求每条“树边”被“非树边”覆盖了多少次

解决方案：树上差分，给树上每一个节点一个初始为0的权值，然后对每条非树边（x,y），令x权值加1，y权值加1，lca(x,y)的权值减2，最后对这棵生成树进行一次dfs，求出f[x]表示以x为根的子树中各节点的权值之和。f[x]就是x与它的父节点之间的“树边”被覆盖的次数

利用树上差分快速求出树上一点在几条给定路径上的模板：[USACO15DEC]Max Flow P

下面我们利用这个模板题所学到的树上差分技巧，分析 noip中是如何运用的呢？

t1.[NOIP2015 提高组] 运输计划 【lca+树上差分+二分答案】

题意：在一棵带权的树上有m条路径，清零一条边的边权使得m条路径的最大值最小

分析：

（1）最长路径最短--->二分--->二分这个最长路径最小值,统计长度>=mid的路径能否在删边后满足长度小于等于mid （求解转判定）

（2）删什么边？--->思考：对于现有的所有长度>=mid的路径，都是不合法的，都需要删边处理

--->得出结论：被所有长度>=mid的路径经过且长度尽量长的边

（3）具体如何统计经过次数？---树上差分！

#include <bits/stdc++.h>
using namespace std;
int head[500005],tot,n,m,dis[500005],dep[500005],f[500005][23];
int d[500005],dmax,cnt[500005];
struct edge{int to,nxt,w;}e[1000005];
struct node{int u,v,lca;}a[500005];
inline int read(){
	int X=0; bool flag=1; char ch=getchar();
	while(ch<'0'||ch>'9') {if(ch=='-') flag=0; ch=getchar();}
	while(ch>='0'&&ch<='9') {X=(X<<1)+(X<<3)+ch-'0'; ch=getchar();}
	if(flag) return X;
	return ~(X-1);
}
void insert(int u,int v,int w){
	e[++tot].nxt=head[u];
	e[tot].to=v;
	e[tot].w=w;
	head[u]=tot;
}
void dfs(int u,int fa){
	dep[u]=dep[fa]+1;f[u][0]=fa;
	for(int i=1;i<=19;i++)f[u][i]=f[f[u][i-1]][i-1];
	for(int i=head[u];i;i=e[i].nxt){
		int v=e[i].to,w=e[i].w;
		if(v==fa)continue;
		dis[v]=dis[u]+w;
		dfs(v,u);
	}
}
int lca(int x,int y){
	if(dep[x]<dep[y])swap(x,y);
	for(int i=19;i>=0;i--){
		if(dep[f[x][i]]>=dep[y])x=f[x][i];
	}
	if(x==y)return x;
	for(int i=19;i>=0;i--){
		if(f[x][i]!=f[y][i])x=f[x][i],y=f[y][i];
	}
	return f[x][0];
}
void cal(int u,int fa,const int num,int &res){
	for(int i=head[u];i;i=e[i].nxt){
		int v=e[i].to,w=e[i].w;
		if(v==fa)continue;
		cal(v,u,num,res);
		if(cnt[v]==num)res=max(res,w);
		cnt[u]+=cnt[v];
	}
}
bool check(int x){
	memset(cnt,0,sizeof(cnt));
	int num=0,res=0;
	for(int i=1;i<=m;i++){
		if(d[i]<=x)continue;
		cnt[a[i].u]+=1;
		cnt[a[i].v]+=1;
		cnt[a[i].lca]-=2;
		++num;
	}
	if(num==0)return x>=dmax;
	cal(1,0,num,res);
	if(dmax-res<=x)return 1;
	return 0;
}
int main(){
	n=read();m=read();
	for(int i=1;i<=n-1;i++){
		int u,v,w;u=read();v=read();w=read();
		insert(u,v,w);insert(v,u,w);
	}
	dfs(1,0);
	for(int i=1;i<=m;i++){
		a[i].u=read();a[i].v=read();
		a[i].lca=lca(a[i].u,a[i].v);
		d[i]=dis[a[i].u]+dis[a[i].v]-2*dis[a[i].lca];
		dmax=max(dmax,d[i]);
	}
	int l=0,r=dmax,ans=-1;
	while(l<=r){
		int mid=(l+r)>>1;
		if(check(mid))ans=mid,r=mid-1;
		else l=mid+1;
	}
	printf("%d\n",ans);
	return 0;
}

（2）倍增处理路径信息

倍增与二进制划分思想互相结合，可以把通常的线性递推优化为成倍增长，如序列中经典的st表，就是利用倍增在nlogn复杂度处理出区间最值信息【模板】ST 表，同样地，倍增也是处理静态树上路径信息的常用手段

[NOIP2013 提高组] 货车运输【lca+生成树】

题意：一棵树，多加了很多无用的边，让你求两条路径上权值的最小值

（1）分析题干：使货车装最重的货物，那么就必须货车走的路载重尽可能大--->载重较小的路是不会被走过的--->构建一棵原图的最大生成树 （【模板】最小生成树）

---然后：求货车能装最大货物重量的问题，就转化成了求树上两点权值最小的边的问题了

（2）朴素算法pass，单次查询会被卡到O(n)--->倍增！

w[i][j]表示i节点到其2^j级祖先之间的最小边权，可以在求lca的过程中处理信息得到答案

#include <bits/stdc++.h>
using namespace std;
int n,m,cnt,head[10005],dep[10005],f[10005],fa[10005][21],w[10005][21];
int x,y,z,q;
bool vis[10005];
struct node{
	int to,nxt,w;
}e[500005];
struct node2{
	int x,y,w;
}et[500005];
void insert(int u,int v,int w){
	e[++cnt].nxt=head[u];e[cnt].to=v;e[cnt].w=w;head[u]=cnt;
}
bool cmp(node2 a,node2 b){return a.w>b.w;}
int find(int x){
	if(f[x]!=x)f[x]=find(f[x]);
	return f[x];
}
void kruskal(){
	sort(et+1,et+1+m,cmp);
	for(int i=1;i<=n;i++)f[i]=i;
	for(int i=1;i<=m;i++){
		if(find(et[i].x)!=find(et[i].y)){
			f[find(et[i].x)]=find(et[i].y);
			insert(et[i].x,et[i].y,et[i].w);
			insert(et[i].y,et[i].x,et[i].w);
		}
	}
}
void dfs(int u){
	vis[u]=1;
	for(int i=head[u];i;i=e[i].nxt){
		int v=e[i].to;
		if(vis[v])continue;
		dep[v]=dep[u]+1;
		fa[v][0]=u;
		w[v][0]=e[i].w;
		dfs(v);
	}
}
int lca(int x,int y){
	if(find(x)!=find(y))return -1;
	int ans=1e9;
	if(dep[x]<dep[y])swap(x,y);
	for(int i=20;i>=0;i--){
		if(dep[fa[x][i]]>=dep[y]){
			ans=min(ans,w[x][i]);
			x=fa[x][i];
		}
	}
		if(x==y)return ans;
		for(int i=20;i>=0;i--){
			if(fa[x][i]!=fa[y][i]){
				ans=min(ans,min(w[x][i],w[y][i]));
				x=fa[x][i];y=fa[y][i];
			}
		}
	ans=min(ans,min(w[x][0],w[y][0]));
	return ans;
}
int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++){
		scanf("%d%d%d",&x,&y,&z);
		et[i].x=x;et[i].y=y;et[i].w=z;
	}
	kruskal();
	for(int i=1;i<=n;i++){
		if(!vis[i]){
			dep[i]=1;dfs(i);fa[i][0]=i;w[i][0]=1e9;
		}
	}
	for(int i=1;i<=20;i++){
		for(int j=1;j<=n;j++){
			fa[j][i]=fa[fa[j][i-1]][i-1];
			w[j][i]=min(w[j][i-1],w[fa[j][i-1]][i-1]);
		}
	}
	scanf("%d",&q);
	while(q--){
		scanf("%d%d",&x,&y);
		printf("%d\n",lca(x,y));
	}
	return 0;
}

还有一道和此题本质相同的题，可作为练习：星际导航

ILoveDuyulin

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
浅析NOIP中的图论【2】

3.LCA的综合运用lca基础芝士（1）树上差分在序列中，我们定义其前缀和与差分序列，把区间的增减转化为左端点加1，右端点减1，根绝差分序列的前缀和是原序列这一原理，在树上也可以进行类似的简化，其中“区间操作”对应“路径操作”，“前缀和”对应“子树和”经典模型：给定一张无向图和一棵生成树，求每条“树边”被“非树边”覆盖了多少次解决方案：树上差分，给树上每一个节点一个初始为0的权值，然后对每条非树边（x,y），令x权值加1，y权值加1，lca(x,y)的权值减2，最后对这棵生成树进行一次d
复制链接

扫一扫