边分治学习笔记

最新推荐文章于 2022-04-29 16:46:19 发布
最新推荐文章于 2022-04-29 16:46:19 发布
阅读量183 收藏 1
点赞数
分类专栏： BZOJ 乱写
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CIao_015/article/details/88368740
版权
BZOJ 同时被 2 个专栏收录
10 篇文章 0 订阅
订阅专栏
乱写
6 篇文章 0 订阅
订阅专栏

对于某些点分治不太好合并两条链的信息的题,可以考虑使用边分治;
边分治时的主要思想跟点分治一样,一直去找某个重心,把一棵树不断化成更小的部分,边分治需要找的这个重心在边上,使得去掉这条边过后两边剩的点的差最小,写法跟点分治都差不多,但是边分治会被菊花图这样的树给卡成 n 2 n^2 n2,所以在边分治之前要重构原树,把原树变成一棵二叉树,具体做法就是新建虚节点然后把真实儿子放在虚二叉树的叶子节点上,这样做就没有数据能把边分治卡下来,空间参考堆式线段树的算法,变成了 4 n 4n 4n的样子;
边分治每次把当前联通快分成了两坨,计算贡献也比点分治方便多了;
以下边分治部分的代码自己yy的,可能写丑了或者傻逼自带大常数了;
后续可能更新题可能也不会;

例题 BZOJ#2870

/*
	Name: BZOJ#2870
	Author: CIao
	Date: 09/03/19 17:08
	Description: 边分治 
*/
#include<bits/stdc++.h>
#define Fst first
#define Snd second
#define RG register
#define mp make_pair
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long LL;
typedef long double LD;
typedef unsigned int UI;
typedef unsigned long long ULL;
template<typename T> inline void read(T& x) {
	char c = getchar();
	bool f = false;
	for (x = 0; !isdigit(c); c = getchar()) {
		if (c == '-') {
			f = true;
		}
	}
	for (; isdigit(c); c = getchar()) {
		x = x * 10 + c - '0';
	}
	if (f) {
		x = -x;
	}
}
template<typename T, typename... U> inline void read(T& x, U& ... y) {
	read(x), read(y...);
}
const int INF=65536+1,N=2e5+10;
int n,p=1,O,Ed,TOT,size,root,MAXV,TMP;
int head[N],A[N],V[N],num[N];
LL ANS;
bool G[N],No[N<<1];
vector<int> E[N];
struct Edge {
	int to,last,w;
	Edge () {}
	Edge (int a,int b,int c) :to(a),last(b),w(c) {}
}edge[N<<1];
void ADD(int a,int b,int c) {
	edge[++p]=Edge(b,head[a],c); head[a]=p;
	edge[++p]=Edge(a,head[b],c); head[b]=p;
}
void Build(int l,int r,int f) {
	if(l>r) return;
	if(l==r) {
		ADD(f,V[l],1);
		return;
	}
	int mid=l+r>>1,rt=++n; A[rt]=A[f];
	ADD(f,rt,0);
	Build(l,mid,rt); Build(mid+1,r,rt);
}
void DFS(int u,int f) {
	int cnt=0;
	for(int i=0;i<(int)E[u].size();++i) if(E[u][i]!=f) V[++cnt]=E[u][i];
	int mid=1+cnt>>1;
	Build(1,mid,u); Build(mid+1,cnt,u);
	for(int i=0;i<(int)E[u].size();++i) if(E[u][i]!=f) DFS(E[u][i],u);
}
void GetEdge(int u,int f) {
	num[u]=1;
	for(int i=head[u];i;i=edge[i].last) {
		int v=edge[i].to;
		if(!No[i]&&v!=f) {
			GetEdge(v,u);
			num[u]+=num[v];
		}
	}
	for(int i=head[u];i;i=edge[i].last) {
		int v=edge[i].to;
		if(!No[i]&&v!=f) {
			if(MAXV>abs(TOT-num[v]*2)) {
				root=u; Ed=i;
				MAXV=abs(TOT-num[v]*2);
			}
		}
	}
}
int cnt,tot;
struct Data {
	int val,dis;
}F[N],P[N];
void Getdis(int u,int f,int val,int dis) {
	val=min(val,A[u]);
	if(G[u]) {
		F[++cnt]=(Data){val,dis+1};
		ANS=max(ANS,1ll*(dis+1)*val);
	}
	for(int i=head[u];i;i=edge[i].last) {
		int v=edge[i].to;
		if(!No[i]&&v!=f) Getdis(v,u,val,dis+edge[i].w);
	}
}
void Calc(int u,int f,int val,int dis) {
	val=min(val,A[u]);
	if(G[u]) P[++tot]=(Data){val,dis+TMP};
	for(int i=head[u];i;i=edge[i].last) {
		int v=edge[i].to;
		if(!No[i]&&v!=f) Calc(v,u,val,dis+edge[i].w);
	}
}
bool cmp(Data A,Data B) {
	return A.val==B.val?A.dis<B.dis:A.val<B.val;
}
void Solve() {
	if(!cnt||!tot) return;
	sort(F+1,F+cnt+1,cmp); sort(P+1,P+tot+1,cmp);
	for(int i=cnt-1;i;--i) F[i].dis=max(F[i].dis,F[i+1].dis);
	int now=1;
	for(int i=1;i<=tot;++i) {
		while(now!=cnt&&F[now].val<P[i].val) ++now;
		if(F[now].val>=P[i].val) ANS=max(ANS,1ll*P[i].val*(P[i].dis+F[now].dis));
	}
}
void DAC(int u1,int e) {
	if(e==-1) return;
	int u2=edge[e].to; No[e]=No[e^1]=true; TMP=edge[e].w;
	cnt=tot=0; Getdis(u1,0,INF,0); Calc(u2,0,INF,0); Solve();
	cnt=tot=0; Getdis(u2,0,INF,0); Calc(u1,0,INF,0); Solve();
	int S1=TOT-num[u2],S2=num[u2];
	root=u1; Ed=-1; MAXV=S1+1; TOT=S1; GetEdge(u1,0); DAC(root,Ed);
	root=u2; Ed=-1; MAXV=S2+1; TOT=S2; GetEdge(u2,0); DAC(root,Ed);
}
//#define rua
int main() {
//	ios::sync_with_stdio(false);
#ifdef rua
#endif
	read(n);
	for(int i=1;i<=n;++i) read(A[i]),G[i]=true;
	for(int i=1;i<n;++i) {
		int u,v; read(u,v);
		E[u].push_back(v); E[v].push_back(u);
	}
	DFS(1,0);
	root=1; Ed=-1; MAXV=n+1; TOT=n; GetEdge(1,0);
	DAC(root,Ed);
	printf("%lld\n",ANS);
	return 0;
}

````对于某些点分治不太好合并两条链的信息的题,可以考虑使用边分治;
边分治时的主要思想跟点分治一样,一直去找某个重心,把一棵树不断化成更小的部分,边分治需要找的这个重心在边上,使得去掉这条边过后两边剩的点的差最小,写法跟点分治都差不多,但是边分治会被菊花图这样的树给卡成$n^2$,所以在边分治之前要重构原树,把原树变成一棵二叉树,具体做法就是新建虚节点然后把真实儿子放在虚二叉树的叶子节点上,这样做就没有数据能把边分治卡下来,空间参考堆式线段树的算法,变成了$4n$的样子;
边分治每次把当前联通快分成了两坨,计算贡献也比点分治方便多了;
以下边分治部分的代码自己yy的,可能写丑了或者傻逼自带大常数了;
#例题 BZOJ#2870
````cpp
/*
	Name: BZOJ#2870
	Author: CIao
	Date: 09/03/19 17:08
	Description: 边分治 
*/
#include<bits/stdc++.h>
#define Fst first
#define Snd second
#define RG register
#define mp make_pair
#define mem(a,b) memset(a,b,sizeof(a))
using namespace std;
typedef long long LL;
typedef long double LD;
typedef unsigned int UI;
typedef unsigned long long ULL;
template<typename T> inline void read(T& x) {
	char c = getchar();
	bool f = false;
	for (x = 0; !isdigit(c); c = getchar()) {
		if (c == '-') {
			f = true;
		}
	}
	for (; isdigit(c); c = getchar()) {
		x = x * 10 + c - '0';
	}
	if (f) {
		x = -x;
	}
}
template<typename T, typename... U> inline void read(T& x, U& ... y) {
	read(x), read(y...);
}
const int INF=65536+1,N=2e5+10;
int n,p=1,O,Ed,TOT,size,root,MAXV,TMP;
int head[N],A[N],V[N],num[N];
LL ANS;
bool G[N],No[N<<1];
vector<int> E[N];
struct Edge {
	int to,last,w;
	Edge () {}
	Edge (int a,int b,int c) :to(a),last(b),w(c) {}
}edge[N<<1];
void ADD(int a,int b,int c) {
	edge[++p]=Edge(b,head[a],c); head[a]=p;
	edge[++p]=Edge(a,head[b],c); head[b]=p;
}
void Build(int l,int r,int f) {
	if(l>r) return;
	if(l==r) {
		ADD(f,V[l],1);
		return;
	}
	int mid=l+r>>1,rt=++n; A[rt]=A[f];
	ADD(f,rt,0);
	Build(l,mid,rt); Build(mid+1,r,rt);
}
void DFS(int u,int f) {
	int cnt=0;
	for(int i=0;i<(int)E[u].size();++i) if(E[u][i]!=f) V[++cnt]=E[u][i];
	int mid=1+cnt>>1;
	Build(1,mid,u); Build(mid+1,cnt,u);
	for(int i=0;i<(int)E[u].size();++i) if(E[u][i]!=f) DFS(E[u][i],u);
}
void GetEdge(int u,int f) {
	num[u]=1;
	for(int i=head[u];i;i=edge[i].last) {
		int v=edge[i].to;
		if(!No[i]&&v!=f) {
			GetEdge(v,u);
			num[u]+=num[v];
		}
	}
	for(int i=head[u];i;i=edge[i].last) {
		int v=edge[i].to;
		if(!No[i]&&v!=f) {
			if(MAXV>abs(TOT-num[v]*2)) {
				root=u; Ed=i;
				MAXV=abs(TOT-num[v]*2);
			}
		}
	}
}
int cnt,tot;
struct Data {
	int val,dis;
}F[N],P[N];
void Getdis(int u,int f,int val,int dis) {
	val=min(val,A[u]);
	if(G[u]) {
		F[++cnt]=(Data){val,dis+1};
		ANS=max(ANS,1ll*(dis+1)*val);
	}
	for(int i=head[u];i;i=edge[i].last) {
		int v=edge[i].to;
		if(!No[i]&&v!=f) Getdis(v,u,val,dis+edge[i].w);
	}
}
void Calc(int u,int f,int val,int dis) {
	val=min(val,A[u]);
	if(G[u]) P[++tot]=(Data){val,dis+TMP};
	for(int i=head[u];i;i=edge[i].last) {
		int v=edge[i].to;
		if(!No[i]&&v!=f) Calc(v,u,val,dis+edge[i].w);
	}
}
bool cmp(Data A,Data B) {
	return A.val==B.val?A.dis<B.dis:A.val<B.val;
}
void Solve() {
	if(!cnt||!tot) return;
	sort(F+1,F+cnt+1,cmp); sort(P+1,P+tot+1,cmp);
	for(int i=cnt-1;i;--i) F[i].dis=max(F[i].dis,F[i+1].dis);
	int now=1;
	for(int i=1;i<=tot;++i) {
		while(now!=cnt&&F[now].val<P[i].val) ++now;
		if(F[now].val>=P[i].val) ANS=max(ANS,1ll*P[i].val*(P[i].dis+F[now].dis));
	}
}
void DAC(int u1,int e) {
	if(e==-1) return;
	int u2=edge[e].to; No[e]=No[e^1]=true; TMP=edge[e].w;
	cnt=tot=0; Getdis(u1,0,INF,0); Calc(u2,0,INF,0); Solve();
	cnt=tot=0; Getdis(u2,0,INF,0); Calc(u1,0,INF,0); Solve();
	int S1=TOT-num[u2],S2=num[u2];
	root=u1; Ed=-1; MAXV=S1+1; TOT=S1; GetEdge(u1,0); DAC(root,Ed);
	root=u2; Ed=-1; MAXV=S2+1; TOT=S2; GetEdge(u2,0); DAC(root,Ed);
}
//#define rua
int main() {
//	ios::sync_with_stdio(false);
#ifdef rua
#endif
	read(n);
	for(int i=1;i<=n;++i) read(A[i]),G[i]=true;
	for(int i=1;i<n;++i) {
		int u,v; read(u,v);
		E[u].push_back(v); E[v].push_back(u);
	}
	DFS(1,0);
	root=1; Ed=-1; MAXV=n+1; TOT=n; GetEdge(1,0);
	DAC(root,Ed);
	printf("%lld\n",ANS);
	return 0;
}
CIao_015
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
边分治实战
实践求真知
10-25 682
数据结构和算法
【边分治】Kuala Lumpur 2008
huyuncong的专栏
11-02 1293
求树上路径第一维之和小于m，第二维最大 #include #include #include #include #include const int maxn=200000,maxm=500000,oo=1073741819; using namespace std; struct sta{ int rt,d,l; }A[maxn]; int tail[maxn],
边分治讲解
weixin_33722405的博客
12-27 214
前言： 　　边分治和点分治一样属于树分治的一部分，相比于点分治，边分治对于与度数相关的问题有着很大的优势，同时边分治也是解决树上最优化问题的一种重要的算法。 分治过程： 　　边分治的分治过程与点分治类似，同样每次分治时找到一条分治中心边使这条边两端的两个联通块中较大的一个尽量小。以分治中心边为界限，恰好将当前分治的联通块中的点分成了两部分，统计路径经过分治中心边的答案，然后将分治中心边断开，...
[学习笔记]边分治
weixin_33894640的博客
02-25 351
基于边的一种分治。统计过中心边的所有路径 可以类比点分治学习 构造： 每次找中心边（使得两侧的sz的最大值最小），然后递归下去 菊花图会卡成链，构造变成O(n^2)。 其实复杂度和度数相关 考虑转化成二叉树 三度化 法一：把所有儿子依次加一个点串起来 法二： 如果儿子多于2个，建立两个儿子虚点，把真正儿子奇偶分类给两个虚点 虚点放在n后面，最后会再...
边分治
weixin_34101784的博客
04-14 128
跟点分治差不多的东西，先转二叉，然后找边，分治。可以动态，还听说有个骚操作叫边分树合并... 注意虚点虚边的处理！注意边分治不能善终，_n = 1的时候特判。 1 void rebuild(int x, int f) { 2 int temp = 0; 3 for(int i = 0; i < (int)G[x].size(); i++) { 4 ...
根号分治与莫队学习笔记自用
12-25
根号分治与莫队学习笔记自用
软件设计师—学习笔记.pdf
03-09
这份学习笔记是针对软件设计师考试的内容总结，它涵盖了软件设计师需要掌握的核心知识点和考试重点，同时也提出了参加软考的重要性和相关考试信息。以下是对给定文件中出现的关键知识点的详细解释： 1. 软件工程...
算法导论 学习笔记.pdf
05-04
算法导论学习笔记 本资源是对《算法导论》的学习笔记，涵盖了算法的基础知识、算法分析、函数的增长、递归式等方面的内容。 一、算法基础知识 算法是指将输入转换为输出的一系列计算步骤，目的是为了有效利用...
监督学习算法学习笔记.pdf
06-03
决策树的学习算法使用递归分治策略，直到所有数据都属于同一类别或无法进一步分割为止。 评估分类器性能的主要指标是分类精度，即在测试集中正确分类的样本数占总样本数的比例。此外，对于不平衡数据集，查准率...
SPOJ QTREE4 Query on a tree IV(边分治)
LJ__
03-31 1211
qtree
树上操作(边分治)
m0_58381738的博客
04-29 597
今天我们浅谈一下树上操作的边分治，首先我们要了解一下什么是边分治。 边分治是指在给定的一个图中，找到一条边，将这条边删去，使得删去这条边后分成的两个图的大小尽可能相等。 边分治和点分治所解决的问题基本上是相同的，但是基于边的分治只需要考虑两棵子树，所以设计算法更为简单。 ...
bzoj2870 边分治
make_it_for_good的博客
08-12 1721
这题写的蛋疼，如果不是吴大爷给我讲了一下也许就gg了。。。边分治为了防止被菊花卡需要建一些虚点和虚边，把一个点的儿子搞成完全二叉树，像这样：其中红色的是虚点和虚边。其中虚点的点权是x的点权。这题路径长度的定义是路径上点的个数， 如果这样的话对于虚点的权值无法处理。 把路径长度转移到边上，原边的长度为1，虚边的长度为0。分治时找一条两边size最大值最小的边分治。强制边两边的两个终点不为虚点。那么路
最长道路tree【边分治】
既然弱小，就只顾变强就是了
04-10 246
题目链接 BZOJ 2870 给定一棵N个点的树，求树上一条链使得链的长度乘链上所有点中的最小权值所得的积最大。 其中链长度定义为链上点的个数。 边分治与点分治类似，都是树分治的一种，与点分治不同的是，边分治找的是分治中心边，而点分治找的是分治重心点。 分治操作是解决了复杂度现在，我们要以我们的分治中心边为基础向两边延伸，所以，至少向两边各自延伸一个点。 但是这样做的复杂度显...
树分治（点分治+边分治）
amourww的博客
03-31 3609
基本相关论文树分治分为点分治O（N和边分治。点分治就是每次找到重心，然后把重心去掉，对分成的每两棵树之间分别统计路径信息（以重心的每个相邻点为根，遍历整棵子树即可得到这个根到每个结点的统计信息），就可以知道包含这个重心的所有路径的信息，然后对于剩下的路径就是在子树里面进行同样的操作了，直到只剩一个点为止（注意这一个点所构成的路径有时也要处理一下）。 边分治就是每次找到一条边，使得删掉这条边后分成的
边分治以及一些树上毒瘤题
Hellsegamosken
05-14 976
算法设计与分析学习笔记
最新发布
05-15
在算法设计与分析学习笔记中，通常会包括以下内容： 1. 基本算法思想的介绍和举例； 2. 常用数据结构的介绍和操作方法； 3. 算法的正确性证明和时间复杂度分析； 4. 算法实现的注意事项和技巧； 5. 算法应用实例和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值