【Ybt OJ】[数据结构 第5章] 倍增(LCA) [后半章]

已于 2022-01-21 11:51:19 修改
阅读量112 收藏
点赞数 1
分类专栏： 洛谷 倍增LCA YbtOJ 文章标签： LCA
于 2021-05-22 10:30:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dgssl_xhy/article/details/117148327
版权
洛谷 同时被 3 个专栏收录
230 篇文章 3 订阅
订阅专栏
YbtOJ
45 篇文章 0 订阅
订阅专栏
倍增LCA
7 篇文章 0 订阅
订阅专栏

「 「 「数据结构 」 」 」第 5 5 5章 倍增问题 ( ( (后 3 3 3题 ) ) )
目录：

D.货车运输
E.运输计划
F.次小生成树

A . A. A. 例题 1 1 1 货车运输

在这里插入图片描述
在这里插入图片描述
洛谷 l i n k link link

分析：

可以发现 一些权值较小的边是不会被走过的 那就可以把这些边去掉 也就是建最大生成树
要得到两点之间最小边权的最大值 最大值就是最大生成树解决
最小边权 就在最大生成树上 L C A LCA LCA 得出的 m i n ( d i s x , d i s y ) min(dis_x,dis_y) min(disx​,disy​)就是了.

CODE：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<vector>
#include<bitset>
//#pragma GCC optimize(2)
#define reg register
using namespace std;
typedef long long ll;
typedef double db;
typedef unsigned long long ull;
const int Inf=0x7fffffff;
const int N=1e4+5;
int n,m,head[N],tot,dep[N],f[N],fa[N][21],dis[N][21];
bool vis[N];
struct node{
	int to,next,k;
}a[N<<3];
struct node2{
	int x,y,dis;
}edge[N<<3];
void add(int x,int y,int k)
{
	a[++tot]=(node){y,head[x],k};
	head[x]=tot;
}
bool cmp(node2 x,node2 y){return x.dis>y.dis;}  //大到小排序
int find(int x){return x==f[x]?x:f[x]=find(f[x]);}
void kruskal()
{
	//大到小排序 就建出最大生成树
	for(int i=1;i<=m;i++)
		if(find(edge[i].x)!=find(edge[i].y))
		{
			f[find(edge[i].x)]=find(edge[i].y);
			add(edge[i].x,edge[i].y,edge[i].dis);
			add(edge[i].y,edge[i].x,edge[i].dis);
		}
	return;
}
void dfs(int x)
{
	vis[x]=1;
	for(int i=head[x];i;i=a[i].next)
	{
		int qwq=a[i].to;
		if(vis[qwq]) continue;
		dep[qwq]=dep[x]+1;
		fa[qwq][0]=x;
		dis[qwq][0]=a[i].k;
		dfs(qwq);
	}
}
int lca(int x,int y)
{
	if(find(x)!=find(y)) return -1;
	int ans=Inf;
	if(dep[y]>dep[x]) swap(x,y);
	for(int i=20;i>=0;i--)
		if(dep[fa[x][i]]>=dep[y])
		{
			ans=min(ans,dis[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(dis[x][i],dis[y][i]));
			x=fa[x][i];
			y=fa[y][i];
		}
	ans=min(ans,min(dis[x][0],dis[y][0]));
	return ans;
}
int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1;i<=m;i++)
	{
		int x,y,k;
		scanf("%d%d%d",&x,&y,&k);
		edge[i].x=x;
		edge[i].y=y;
		edge[i].dis=k;
	}
	sort(edge+1,edge+m+1,cmp);
	for(int i=1;i<=n;i++) f[i]=i;
	kruskal();
	for(int i=1;i<=n;i++)
		if(!vis[i])
		{
			dep[i]=1;
			dfs(i);
			fa[i][0]=i;
			dis[i][0]=Inf;
		}
	for(int i=1;i<=20;i++)
		for(int j=1;j<=n;j++)
		{
			fa[j][i]=fa[fa[j][i-1]][i-1];
			dis[j][i]=min(dis[j][i-1],dis[fa[j][i-1]][i-1]);
		}
	int T;
	scanf("%d",&T);
	while(T--)
	{
		int x,y;
		scanf("%d%d",&x,&y);
		printf("%d\n",lca(x,y));
	}
	
	return 0;
}

E . E. E. 例题 5 5 5 运输计划

在这里插入图片描述
在这里插入图片描述
洛谷 l i n k link link

分析：

求树上距离 就会想到 L C A LCA LCA
肯定要找长度最长的边用虫洞 但是这条边必须被所有路径经过
那就可以统计边的出现次数 出现次数 = = =路径数量 就选出长度最大一条 看最长路径 − - −最长边 < = <= <=要求时间

要求时间就是二分的 m i d mid mid了 r r r是最长路径 l l l是最长路径 − - −最长边
统计边次数 相当于区间 + 1 +1 +1 那就可以差分解决

CODE：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<vector>
#include<bitset>
//#pragma GCC optimize(2)
#define reg register
using namespace std;
typedef long long ll;
typedef double db;
typedef unsigned long long ull;
const int N=3e5+5;
int n,m,head[N],tot,fa[N][21],dis[N][21],dep[N];
int ans,val[N],cnt,l,r,mid;
struct node{
	int to,next,x;
}edge[N<<1];
struct node2{
	int x,y,lca,dis;
}a[N];
bool cmp(node2 x,node2 y){return x.dis>y.dis;}
void add(int x,int y,int k)
{
	edge[++tot]=(node){y,head[x],k};
	head[x]=tot;
}
void dfs(int x,int father)
{
	fa[x][0]=father;
	dep[x]=dep[father]+1;
	for(int i=head[x];i;i=edge[i].next)
	{
		int qwq=edge[i].to;
		if(qwq!=father)
		{
			dfs(qwq,x);
			dis[qwq][0]=edge[i].x;
		}
	}
}
int LCA(int x,int y,int p)
{
	if(dep[y]>dep[x]) swap(x,y);
	for(int i=20;i>=0;i--)
		if(dep[fa[x][i]]>=dep[y])
		{
			a[p].dis+=dis[x][i];
			x=fa[x][i];
		}
	if(x==y) return x;
	for(int i=20;i>=0;i--)
		if(fa[x][i]!=fa[y][i])
		{
			a[p].dis+=dis[x][i]+dis[y][i];
			x=fa[x][i];
			y=fa[y][i];
		}
	a[p].dis+=dis[x][0]+dis[y][0];
	return fa[x][0];
}
void ret(int x,int father)
{
	for(int i=head[x];i;i=edge[i].next)
	{
		int qwq=edge[i].to;
		if(qwq!=father)
		{
			ret(qwq,x);
			val[x]+=val[qwq];
		}
	}
}
bool check(int x)
{
	cnt=0;
	memset(val,0,sizeof(val));
	for(int i=1;i<=m;i++)
	{
		if(a[i].dis<=x) break;
		val[a[i].lca]--;
		val[a[i].x]++;
		val[a[i].lca]--;
		val[a[i].y]++;
		cnt++;
	}
	ret(1,0);
	int maxn=0;
	for(int i=1;i<=n;i++)
		if(val[i]==cnt)
			maxn=max(maxn,dis[i][0]);  //选权值最大用虫洞
	return a[1].dis-maxn<=mid?1:0;
}
int main()
{
	scanf("%d%d",&n,&m);
	for(int i=1;i<n;i++)
	{
		int x,y,k;
		scanf("%d%d%d",&x,&y,&k);
		add(x,y,k);
		add(y,x,k);
		l=max(l,k);
	}
	dfs(1,0);
	for(int i=1;i<=20;i++)
		for(int j=1;j<=n;j++)
		{
			fa[j][i]=fa[fa[j][i-1]][i-1];
			dis[j][i]=dis[j][i-1]+dis[fa[j][i-1]][i-1];
		}
	for(int i=1;i<=m;i++)
	{
		scanf("%d%d",&a[i].x,&a[i].y);
		a[i].lca=LCA(a[i].x,a[i].y,i);
		r=max(r,a[i].dis);
	}
	l=r-l;
	sort(a+1,a+m+1,cmp);
	while(l<=r)
	{
		mid=(l+r)>>1;
		if(check(mid))
		{	
			ans=mid;
			r=mid-1;
		}
		else l=mid+1;
	}
	printf("%d",ans);
	
	return 0;
	
}

F . F. F. 例题 6 6 6 次小生成树

在这里插入图片描述
洛谷 l i n k link link

分析：

思路：倍增 L C A + K r u s k a l LCA+Kruskal LCA+Kruskal
K r u s k a l Kruskal Kruskal有被证明 任意 ( x , y ) (x,y) (x,y)之间的边权最大值 < = ( x , y ) <=(x,y) <=(x,y)之间未被选入边的边权 ( ( (毕竟 K r u s k a l Kruskal Kruskal是贪心求最小生成树 ) ) )

所以 不严格次小生成树 只要遍历每条不选边的 ( x , y , k ) (x,y,k) (x,y,k) 替换 ( x , y ) (x,y) (x,y)的最大边
但要求的是 严格次小生成树
不严格在哪 ? ? ? 小于等于 等于了就不是严格次小
所以还要找个次大边 用 L C A LCA LCA分别求 最大边和次大边 最后去替换

CODE：

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<vector>
#include<bitset>
//#pragma GCC optimize(2)
#define reg register
#define Inf 2147483647000000
using namespace std;
typedef long long ll;
typedef double db;
typedef unsigned long long ull;
const int N=4e5+5,M=9e5+5;
struct node{
	ll x,y,k,next;
}a[M<<1],G[N<<1];
ll tot,head[N],fa[N][19],maxn[N][19],minn[N][19],dep[N],father[N],ans=Inf;
ll n,m;
bool vis[M<<1];
inline void add(ll x,ll y,ll k)
{
	G[++tot]=(node){x,y,k,head[x]};
	head[x]=tot;
}
inline void dfs(ll x,ll father)
{
	fa[x][0]=father;
	for(reg ll i=head[x];i;i=G[i].next)
	{
		ll qwq=G[i].y;
		if(qwq==father) continue;
		dep[qwq]=dep[x]+1ll;
		maxn[qwq][0]=G[i].k;
		minn[qwq][0]=-Inf;
		dfs(qwq,x);
	}
}
inline bool cmp(node x,node y){return x.k<y.k;}
inline ll find(ll x){return x==father[x]?x:father[x]=find(father[x]);}
inline ll LCA(ll x,ll y)
{
	if(dep[x]<dep[y]) swap(x,y);
	for(reg ll i=18;i>=0;i--)
	{ 
		if(dep[fa[x][i]]>=dep[y])
			x=fa[x][i];
	}
	if(x==y) return x;
	for(reg ll i=18;i>=0;i--)
		if(fa[x][i]!=fa[y][i])
		{
			x=fa[x][i];
			y=fa[y][i];
		}
	return fa[x][0];
}
inline ll query(ll x,ll y,ll val)
{
	ll res=-Inf;
	for(reg ll i=18;i>=0;i--)
	{
		if(dep[fa[x][i]]>=dep[y])
		{
			if(val!=maxn[x][i]) res=max(res,maxn[x][i]);
			else res=max(res,minn[x][i]);
			x=fa[x][i];
		}
	}
	return res;
}
int main()
{
	scanf("%lld%lld",&n,&m);
	for(ll i=1;i<=m;i++)
		scanf("%lld%lld%lld",&a[i].x,&a[i].y,&a[i].k);
	sort(a+1,a+m+1,cmp);
	for(reg ll i=1;i<=n;i++)
		father[i]=i;
	ll cnt=0ll;
	for(reg ll i=1;i<=m;i++)
	{
		ll fx=find(a[i].x),fy=find(a[i].y);
		if(fx!=fy)
		{
			cnt+=a[i].k;
			father[fx]=fy;
			add(a[i].x,a[i].y,a[i].k);
			add(a[i].y,a[i].x,a[i].k);
			vis[i]=1;
		}
	}	
	minn[1][0]=-Inf;
	dep[1]=1ll;
	dfs(1,-1);
	
	for(reg ll i=1;i<=18;i++)
		for(reg ll j=1;j<=n;j++)
		{
			fa[j][i]=fa[fa[j][i-1]][i-1];
			maxn[j][i]=max(maxn[j][i-1],maxn[fa[j][i-1]][i-1]);  //最大
			minn[j][i]=max(minn[j][i-1],minn[fa[j][i-1]][i-1]);  //次大
			if(maxn[j][i-1]>maxn[fa[j][i-1]][i-1]) 
				minn[j][i]=max(minn[j][i],maxn[fa[j][i-1]][i-1]);
			else if(maxn[j][i-1]<maxn[fa[j][i-1]][i-1])
				minn[j][i]=max(minn[j][i],maxn[j][i-1]);
		}
	for(reg ll i=1;i<=m;i++)
	{
		if(!vis[i])
		{
			ll lca=LCA(a[i].x,a[i].y);
			ll maxx=query(a[i].x,lca,a[i].k);
			ll maxy=query(a[i].y,lca,a[i].k);
			ans=min(ans,cnt-max(maxx,maxy)+a[i].k); //替换
		}
	}
	printf("%lld\n",ans);
	
	return 0;
	
}
EschatonAyane
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
【Ybt OJ】[图论 第3章] 最短路径
绫
03-06 161
「「「图论」」」第333章 最短路径 目录： A.单源最短路径 B.判断负环 C.最优贸易 D.汽车加油 A.A.A. 例题111 单源最短路径 洛谷linklinklink 分析： 最短路模板 这不是弱化版 dijkstra+dijkstra+dijkstra+堆优化即可 也可以把普通spfaspfaspfa的queuequeuequeue改成priorityqueuepriority_queuepriorityq​ueue就过了 CODE： #include<iostream> #inc
【Ybtoj 第18章例4】货车运输【倍增问题】
在人间贩卖声音
06-03 173
解题思路 首先，我们要求出最大生成树。这样做的原因是司机为了让自己能过通过载运更多的货物，显然会选择边权大的两边，由此可以推出我们要求的是最大生成树，去除原来的图中边权比较小的那些边。 得到了这样一个树之后，我们便考虑如何求出两个节点之间最小边权的最大值（即为题中的最大载重），因为这两点之间的路径是唯一的，我们只需要找出这条路径便可以得到答案。我们可以通过LCA来做到这一点。 这一步是LCA一个经典运用：静态树上链的权值查询问题。具体做法是在求出f数组的同时顺便求出一个dis数组，disi,jd...
【Ybt OJ】[数据结构 第5章] 倍增(LCA) [前半章]
绫
05-14 133
「「「数据结构」」」第555章 倍增问题(((前333题))) 目录： A.查找编号 B.开车旅行 C.树上距离 A.A.A. 例题111 查找编号 洛谷linklinklink 分析： 直接lowerlowerlower_bound()bound()bound()就搞完了 也可以倍增 比它小就一直跳 最后输出倍增到的位置或−1-1−1 CODE： #include<iostream> #include<cstdio> #include<algorithm> #inc
【Ybt OJ】[数据结构 第4章] 线段树 [后半章]
绫
05-03 102
「「「数据结构」」」第444章 线段树(((后222题))) 目录： D.维护序列 E.字符串排序 大家好 我是个菜鸡 我非常喜欢暴力数据结构 于是我用线段树过了这些题（ D.D.D. 例题444 维护序列 洛谷link1link1link1 洛谷link2link2link2 分析： 和例题222差不多 就是加了个乘操作 但要注意 维护lazylazylazy标记 和下传时 先乘再加 因为 如果维护的是aaa lazylazylazy标记有+c+c+c和×b\times b×b 但是 a×b+c≠(
【Ybt OJ】[数据结构 第2章] 树状数组 [后半章]
绫
04-07 145
「「「数据结构」」」第222章 树状数组(((后333题))) 目录： D.区间修改区间查询 E.单点修改区间查询(2维) F.区间修改区间查询(2维) D.D.D. 例题444 区间修改区间查询 分析： 树状数组一般只能实现单点修改 若维护序列aaa的差分数组bbb 我们对aaa的一个前缀rrr求和 即 ∑i=1rai\sum_{i=1}^ra_i∑i=1r​ai​ 由差分数组定义得 aia_iai​ === ∑j=1ibj\sum_{j=1}^ib_j∑j=1i​bj​ 进行推导 ∑i=1rai\
【Ybt OJ】[数据结构 第1章] 二叉堆
绫
03-31 127
「「「数据结构」」」第111章 二叉堆 目录： A.合并果子 B.序列合并 C.龙珠游戏 D.工作安排 A.A.A. 例题111 合并果子 洛谷linklinklink 分析： 就是从小到大 不断累加 但你肯定不能 加一次 排一次序 然后反手一个stlstlstl小根堆切掉了（ CODE： #include<iostream> #include<cstdio> #include<algorithm> #include<cstring> #include&l
【Ybt OJ】[数据结构 第4章] 线段树 [前半章]
绫
04-16 97
「「「数据结构」」」第444章 线段树(((前333题))) 目录： A.求区间和 B.区间查改 C.小白逛公园 大家好 我是个菜鸡 我非常喜欢暴力数据结构 于是我用线段树过了这些题 A.A.A. 例题111 求区间和 洛谷linklinklink 分析： 那就树状数组 线段树过了呗 模板 CODE： #include<iostream> #include<cstdio> #include<algorithm> #include<cstring> #in
【Ybt OJ】[数据结构 第2章] 树状数组 [前半章]
绫
04-06 89
「「「数据结构」」」第222章 树状数组(((前333题))) 目录： A.单点修改区间查询 B.逆序对 C.严格上升子序列数 A.A.A. 例题111 单点修改区间查询 洛谷linklinklink 分析： 树状数组模板题 区间和就 前缀和相减 CODE： #include<iostream> #include<cstdio> #include<algorithm> #include<cstring> #include<cmath> #in
【Ybt OJ】[数据结构 第3章] RMQ问题 (ST表) [后半章]
绫
04-14 118
「「「数据结构」」」第333章 RMQRMQRMQ问题(((后222题))) 目录： C.与众不同 D.矩阵最值 C.C.C. 例题333 与众不同 分析： headihead_iheadi​表示以iii结尾完美序列 的起点 lenilen_ileni​表示以iii结尾最长完美序列 的长度 locxloc_xlocx​表示最近的xxx出现的位置 注意 ∣ai∣<=106|a_i|<=10^6∣ai​∣<=106的 那你就要处理负数 把下标加上10610^6106 然后二分起点 再sts
第4章 倍增求LCA 测试数据.rar
12-02
http://ybt.ssoier.cn:8088 信息学奥赛一本通(提高篇)测试数据\第4部分 数据结构(提高篇)\ 第4章 倍增求LCA 测试数据
第5章 树链剖分 测试数据.rar
12-02
http://ybt.ssoier.cn:8088 信息学奥赛一本通(提高篇)测试数据\第4部分 数据结构(提高篇)\ 第5章 树链剖分 测试数据
第5章 单调队列优化动态规划 测试数据.rar
12-02
http://ybt.ssoier.cn:8088 信息学奥赛一本通(提高篇)测试数据\第5部分 动态规划(提高篇) 第5章 单调队列优化动态规划 测试数据
第3章 线段树 测试数据.rar
12-02
http://ybt.ssoier.cn:8088 信息学奥赛一本通(提高篇)测试数据\第4部分 数据结构(提高篇)\ 第3章 线段树 测试数据
第3章 数位动态规划 测试数据.rar
12-02
http://ybt.ssoier.cn:8088 信息学奥赛一本通(提高篇)测试数据\第5部分 动态规划(提高篇) 第3章 数位动态规划 测试数据
【Ybt OJ】[基础算法 第1章]递推算法
绫
12-25 2120
「「「基础算法」」」第1章 递推算法 目录： A.错排问题 B.奇怪汉诺塔 C.数的划分 D.传球游戏 E.平铺方案 A.A.A. 例题1 错排问题 分析： 考虑第nnn个元素 放在kkk位上 那么有(n−1)(n-1)(n−1)种方案(k≠n)(k≠n)(k​=n) 再考虑这个kkk 当它在nnn位时 就有由于n,kn,kn,k两元素位置相同 其他n−2n-2n−2个元素错排即可 当kkk不在nnn位时 直接n−1n-1n−1个元素错排 递推式：fn=(n−1)∗(fn−1+fn−2)f_n=(n-
【Ybt OJ】[字符串算法 第2章] 哈希Hash [前半章]
绫
01-22 320
「「「字符串算法」」」第222章 HashHashHash和HashHashHash表 目录： A.字符串哈希 B.回文子串 C.对称正方形 A.A.A. 例题111 字符串哈希 洛谷linklinklink 分析： 可以直接暴力找 跑的比单哈希还快 可还行. 也可以一个哈希搞完 也可以无错哈希 以及字典树.（bushi（bushi（bushi 暴力CODE： #include<iostream> #include<cstdio> #include<algorithm&gt
【Ybt OJ】[基础算法 第5章] 广度搜索 [后半章]
绫
01-21 298
「「「基础算法」」」 第555章 广度搜索(((前333题))) 前半章linklinklink 目录： D.荆轲刺秦王 E.电路维修 F.逃离噩梦 又臭又长的codecodecode D.D.D. 例题444 荆轲刺秦王 洛谷linklinklink 分析： 由于一本通上的数据较水 可以直接bfsbfsbfs模拟 先找出起点终点的位置 然后把图转化成010101图 也就是可以直接看哪个位置 可以走 节省空间 方便处理 关于技能： 隐身：判断不合法时不用考虑010101图就行 瞬移：在方向数组里多加4
【Ybt OJ】[基础算法 第2章]贪心算法
绫
01-02 254
「「「基础算法」」」第222章 贪心算法 目录： A.奶牛晒衣服 B.雷达装置 C.畜栏预定 D.国王游戏 A.A.A. 例题111 奶牛晒衣服 分析： 干衣所需时间是取决于最后一件烘干的衣物的所需时间 所以我们每次对剩余时间最多的衣物用烘干机 对于剩余时间最多 我们可以用一个大根堆维护 sortsortsort会超时 CODE： #include<cstdio> #include<iostream> #include<algorithm> #include<
ybt.ssoier.cn 8088
最新发布
09-18
在计算机网络中，不同的应用程序需要使用不同的端口号来进行通信，以便正确地将数据传输到指定的应用程序。端口号的范围是从0到65535，其中0到1023是系统保留端口，一般用于一些特定的服务，而8088则是一个非系统...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值