简单的圆方树（一）

最新推荐文章于 2021-12-06 17:37:56 发布
最新推荐文章于 2021-12-06 17:37:56 发布
阅读量1.1k 收藏 3
点赞数 1
分类专栏： 图论 圆方树 文章标签： 图论 圆方树 Tarjan
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hwzzyr/article/details/82858289
版权

圆方树是什么呢？

我们先不管仙人掌，来看看一般图的圆方树。
众所周知， T a r j a n Tarjan Tarjan算法可以在强连通分量，点双和边双三个地方使用。
有向图是强联通，无向图是双联通。
我们使用 T a r j a n Tarjan Tarjan算法很多时候都是为了将图简化以达到目的。
S c c Scc Scc缩点之后会形成一张 D A G DAG DAG图，用 T o p   S o r t Top\ Sort Top Sort可以解决许多问题。
边双缩点之后就直接形成了一棵树。
只有点双与众不同，点双中的割点是属于多个块的，所以emmm~~~
接下来就要用到圆方树了!

似乎多数圆方树有关的讲解都有这张图
(借了一张图，读书人的事……2333)
简单来说，就是对原图的每一个点双分量新建一个方点，然后将原有分量中的点连向它。
这样就避免了割点归属的争论了,完美的表现了割点属于多个块的性质(搁置争议共同开发)。
emm，说完了。

1.无论取哪个点为根，圆方树的形态是一样的
2.一定是个森林
3.每个点双有唯一的方点
4.圆点方点相间分布，相同点不相邻

具体的性质各位可以参考一下UOJ
接下来就是简单的例题时间了。

【BJOI2013】压力
Description
如今，路由器和交换机构建起了互联网的骨架。处在互联网的骨干位置的核心路由器典型的要处理100Gbit/s的网络流量。他们每天都生活在巨大的压力之下。
小强建立了一个模型。这世界上有N个网络设备，他们之间有M个双向的链接。这个世界是连通的。在一段时间里，有Q个数据包要从一个网络设备发送到另一个网络设备。
一个网络设备承受的压力有多大呢？很显然，这取决于Q个数据包各自走的路径。不过，某些数据包无论走什么路径都不可避免的要通过某些网络设备。
你要计算：对每个网络设备，必须通过（包括起点、终点）他的数据包有多少个？
Input
第一行包含3个由空格隔开的正整数N，M，Q。
接下来M行，每行两个整数u，v，表示第u个网络设备（从1开始编号）和第v个网络设备之间有一个链接。u不会等于v。两个网络设备之间可能有多个链接。
接下来Q行，每行两个整数p，q，表示第p个网络设备向第q个网络设备发送了一个数据包。p不会等于q。
Output
输出N行，每行1个整数，表示必须通过某个网络设备的数据包的数量。
Sample Input
4 4 2
1 2
1 3
2 3
1 4
4 2
4 3
Sample Output
2
1
1
2
Hint
【数据范围与约定】
样例解释：
设备1、2、3之间两两有链接，4只和1有链接。4想向2和3各发送一个数据包。显然，这两个数据包必须要经过它的起点、终点和1。
数据规模：
对于40%的数据，1<=N,M,Q<=2000
对于60%的数据，1<=N,M,Q<=40000
对于100%的数据，1<=N<=100000，1<=M,Q<=200000

我们知道，在一个点双联通分量中，任意两点之间都有点不重复的路径。
所以之间建出圆方树，然后两点之间的链上圆点(也就是割点)就是一定会经过的点。
树上差分即可。
有趣的是，我的差分方式有点毒瘤，仿照树剖得出Dfs序之后在序列上差分。
这样就没有求Lca的过程了，时间复杂度 O ( n l o g n ) O(nlogn) O(nlogn)

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
const int Maxn=200005;
inline int read() {
	char c; int rec=0;
	while((c=getchar())<'0'||c>'9');
	while(c>='0'&&c<='9') rec=rec*10+c-'0',c=getchar();
	return rec;
}
int n,m,Q;
struct Branch {int next,to;} branch[Maxn<<1];
int h[Maxn],cnt=0;
inline void add(int x,int y) {
	branch[++cnt].to=y; branch[cnt].next=h[x]; h[x]=cnt; return ;
}
Branch edge[Maxn<<2];
int e[Maxn<<1],idx=0;
inline void Add(int x,int y) {
	edge[++idx].to=y; edge[idx].next=e[x]; e[x]=idx; return ;
}
int Bcc,bl[Maxn<<1];
int dfn[Maxn<<1],low[Maxn<<1],ind=0;
int S[Maxn<<1],Top=0;
void Tarjan(int v) {
	dfn[v]=low[v]=++ind; S[++Top]=v;
	for(int i=h[v];i;i=branch[i].next) {
		int j=branch[i].to;
		if(!dfn[j]) {
			Tarjan(j); low[v]=min(low[v],low[j]);
			if(low[j]>=dfn[v]) {
				int p=0; ++Bcc; 
				Add(Bcc,v); Add(v,Bcc);
				while(p!=j) {
					p=S[Top--];
					Add(Bcc,p); Add(p,Bcc);
				}
			}
		}
		else low[v]=min(low[v],dfn[j]);
	} return ;
}
int size[Maxn<<1],deep[Maxn<<1];
int top[Maxn<<1],fa[Maxn<<1],son[Maxn<<1];
int id[Maxn],tnt=0;
void Dfs1(int v,int pre,int dep) {
	size[v]=1; fa[v]=pre; deep[v]=dep;
	for(int i=e[v];i;i=edge[i].next) {
		int j=edge[i].to;
		if(j==pre) continue;
		Dfs1(j,v,dep+1); size[v]+=size[j];
		if(size[son[v]]<size[j]) son[v]=j;
	} return ;
}
void Dfs2(int v,int T) {
	top[v]=T; id[v]=++tnt;
	if(son[v]) Dfs2(son[v],T);
	for(int i=e[v];i;i=edge[i].next) {
		int j=edge[i].to;
		if(j!=fa[v]&&j!=son[v]) Dfs2(j,j);
	} return ;
}
int sum[Maxn<<1];
int main() {
	n=read(); m=read(); Q=read();
	for(int i=1;i<=m;++i) {
		int x=read(),y=read();
		add(x,y); add(y,x);
	}
	Bcc=n; Tarjan(1);
	Dfs1(1,0,1); Dfs2(1,1);
	for(int i=1;i<=Q;++i) {
		int x=read(),y=read();
		while(top[x]!=top[y]) {
			if(deep[top[x]]<deep[top[y]]) swap(x,y);
			++sum[id[top[x]]]; --sum[id[x]+1];
			x=fa[top[x]];
		}
		if(deep[x]<deep[y]) swap(x,y);
		++sum[id[y]]; --sum[id[x]+1];
	}
	for(int i=1;i<=Bcc;++i) sum[i]+=sum[i-1];
	for(int i=1;i<=n;++i) cout<<sum[id[i]]<<'\n';
	return 0;
}

圆方树显然可以解决一些带修改的问题。
这里我们要注意一下圆方树的维护。
显然，如果没修改一次圆点就修改所有与之相连的方点的话，在菊花图面前会死的很惨。
于是我们随便拿一个圆点当作圆方树的根，所有的方点维护的信息都不包括父亲节点(当然是一个圆点)。 当我们访问到当前联通块时特判后加上父亲圆点的贡献即可。
题目链接
题目大意：给出一张无向图，然后每次询问两点之间简单路径的最小值，支持修改点权。
首先按照前面的说法建好圆方树，然后就是维护链上的最小值。同时，用multiset来维护方点的最小值(相当于一个支持删除的小根堆)。配合树链剖分+线段树就解决问题了。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<set>
using namespace std;
const int Maxn=200005;
inline int read() {
   char c; int rec=0;
   while((c=getchar())<'0'||c>'9');
   while(c>='0'&&c<='9') rec=rec*10+c-'0',c=getchar();
   return rec;
}
int n,m,Q,val[Maxn];
struct Graph {
   struct Branch {int next,to;} branch[Maxn<<1];
   int h[Maxn],cnt;
   inline void add(int x,int y) {
   	branch[++cnt].to=y; branch[cnt].next=h[x]; h[x]=cnt; return ;
   }
} G,T;
int Bcc,dfn[Maxn],low[Maxn],idx,S[Maxn],Top;
void Tarjan(int v) {
   dfn[v]=low[v]=++idx; S[++Top]=v;
   for(int i=G.h[v];i;i=G.branch[i].next) {
   	int j=G.branch[i].to;
   	if(!dfn[j]) {
   		Tarjan(j); low[v]=min(low[v],low[j]);
   		if(low[j]>=dfn[v]) {
   			int p=0; ++Bcc; 
   			T.add(Bcc,v); T.add(v,Bcc);
   			while(p!=j) {
   				p=S[Top--];
   				T.add(Bcc,p); T.add(p,Bcc);
   			}
   		}
   	}
   	else low[v]=min(low[v],dfn[j]);
   } return ;
}
multiset<int> U[Maxn<<1];
int D,Minn[Maxn<<3];
int size[Maxn<<1],deep[Maxn<<1];
int top[Maxn<<1],fa[Maxn<<1],son[Maxn<<1];
int id[Maxn<<1],ind;
void Dfs1(int v,int pre,int dep) {
   if(v<=n) U[v].insert(val[v]);
   size[v]=1; fa[v]=pre; deep[v]=dep;
   for(int i=T.h[v];i;i=T.branch[i].next) {
   	int j=T.branch[i].to;
   	if(j==pre) continue;
   	Dfs1(j,v,dep+1); size[v]+=size[j];
   	if(size[son[v]]<size[j]) son[v]=j;
   	if(v>n) U[v].insert(val[j]);
   } return ;
}
void Dfs2(int v,int TOP) {
   top[v]=TOP; id[v]=++ind;
   if(son[v]) Dfs2(son[v],TOP);
   for(int i=T.h[v];i;i=T.branch[i].next) {
   	int j=T.branch[i].to;
   	if(j!=fa[v]&&j!=son[v]) Dfs2(j,j);
   } return ;
}
inline int Ask(int L,int R) {
   int rec=0x3f3f3f3f;
   for(int s=L+D-1,t=R+D+1;s^t^1;s>>=1,t>>=1) {
   	if(~s&1) rec=min(rec,Minn[s^1]);
   	if(t&1) rec=min(rec,Minn[t^1]);
   } return rec;
}
int main() {
   n=read(); m=read(); Q=read();
   for(int i=1;i<=n;++i) val[i]=read();
   for(int i=1;i<=m;++i) {
   	int x=read(),y=read();
   	G.add(x,y); G.add(y,x);
   }
   char ch;
   Bcc=n; Tarjan(1);
   Dfs1(1,0,1); Dfs2(1,1);
   D=1; while(D<=Bcc) D<<=1;
   memset(Minn,0x3f,sizeof(Minn));
   for(int i=1;i<=Bcc;++i) Minn[D+id[i]]=*U[i].begin();
   for(int i=D;i;--i) Minn[i]=min(Minn[i<<1],Minn[i<<1|1]);
   for(int i=1;i<=Q;++i) {
   	while((ch=getchar())!='A'&&ch!='C');
   	int x=read(),y=read();
   	if(ch=='A') {
   		int Ans=0x3f3f3f3f;
   		while(top[x]!=top[y]) {
   			if(deep[top[x]]<deep[top[y]]) swap(x,y);
   			Ans=min(Ans,Ask(id[top[x]],id[x]));
   			x=fa[top[x]];
   		}
   		if(deep[x]<deep[y]) swap(x,y);
   		Ans=min(Ans,Ask(id[y],id[x]));
   		if(y>n) Ans=min(Ans,val[fa[y]]);
   		cout<<Ans<<'\n';
   	}
   	else {
   		int p=fa[x];
   		if(p) {
   			U[p].erase(U[p].find(val[x])); U[p].insert(y);
   			int v=id[p]+D; Minn[v]=*U[p].begin(); v>>=1;
   			while(v) Minn[v]=min(Minn[v<<1],Minn[v<<1|1]),v>>=1;
   		}
   		val[x]=y;
   		int v=id[x]+D; Minn[v]=y; v>>=1;
   		while(v) Minn[v]=min(Minn[v<<1],Minn[v<<1|1]),v>>=1;
   	}
   }
   return 0;
}

除了可以辅助数据结构来暴力维护图上信息之外，圆方树还可以将图上的 d p dp dp转化为树上的 d p dp dp。
LOJ 【APIO2018】铁人两项
简单来说，就是找原图中有多少在同一简单路上的三元组。
一种统计方法是枚举s和f，然后计算从s到f的点不重复路径中可以经过的点的个数。
设每个圆点的权值为−1，每个方点的权值为点双大小，那么选法就是两点路径的权值和吧。
O ( n 2 ) O(n^2) O(n2)任然不行，所以我们考虑计算一下每个点的贡献。

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
const int Maxn=200005,Maxm=400005;
inline int read() {
	char c; int rec=0;
	while((c=getchar())<'0'||c>'9');
	while(c>='0'&&c<='9') rec=rec*10+c-'0',c=getchar();
	return rec;
}
int n,m;
long long ans;
struct Graph {
	struct Branch {int next,to;} branch[Maxm<<1];
	int h[Maxn<<1],cnt;
	inline void add(int x,int y) {
		branch[++cnt].to=y; branch[cnt].next=h[x]; h[x]=cnt; return ;
	}
} G,T;
int size[Maxn<<1],tot;
int Bcc,dfn[Maxn],low[Maxn],S[Maxn],w[Maxn],idx,num;
void Tarjan(int v) {
	dfn[v]=low[v]=++idx; S[++num]=v; w[v]=-1;
	for(int i=G.h[v];i;i=G.branch[i].next) {
		int j=G.branch[i].to;
		if(!dfn[j]) {
			Tarjan(j); low[v]=min(low[v],low[j]);
			if(low[j]>=dfn[v]) {
				int p=0; ++Bcc; ++w[Bcc];
				T.add(Bcc,v); T.add(v,Bcc);
				while(p!=j)
					p=S[num--],++w[Bcc],T.add(Bcc,p),T.add(p,Bcc);
			}
		}
		else low[v]=min(low[v],dfn[j]);
	} return ;
}
void Getsize(int v,int pre) {
	size[v]=v<=n;
	for(int i=T.h[v];i;i=T.branch[i].next) {
		int j=T.branch[i].to;
		if(j==pre) continue;
		Getsize(j,v); size[v]+=size[j];
	} return ;
}
void Sov(int v,int pre) {
	int opt=v<=n;
	for(int i=T.h[v];i;i=T.branch[i].next) {
		int j=T.branch[i].to;
		if(j==pre) continue;
		Sov(j,v); ans+=1ll*opt*w[v]*size[j]; opt+=size[j];
	}
	ans+=1ll*size[v]*(tot-size[v])*w[v];
	return ;
}
int main() {
	n=read(); m=read();
	for(int i=1;i<=m;++i) {
		int x=read(),y=read();
		G.add(x,y); G.add(y,x);
	}
	Bcc=n;
	for(int i=1;i<=n;++i)
		if(!dfn[i]) 
			Tarjan(i),Getsize(i,0),tot=size[i],Sov(i,0);
	cout<<(ans<<1);
	return 0;
}
hwzzyr
关注
专栏目录
【算法学习】圆方树
weixin_30809173的博客
02-27 698
目录 一、圆方树的定义 二、圆方树的构建 三、圆方树的应用 [APIO2018]铁人两项 题意简述： 题解： [CodeForces 487E]Tourists 题意简述： 题解： ...
推荐洛谷网站：全面解析与实用指南
最新发布
2301_81482480的博客
10-02 1458
洛谷作为中国领先的在线编程学习和竞赛平台，提供了丰富的编程题目、高效的在线评测系统、活跃的社区氛围以及丰富的学习资源。通过合理的使用技巧和实战应用，用户可以大大提高编程能力和竞赛水平。希望本文能帮助你更好地了解和使用洛谷，提升你的编程技能。无论你是编程初学者还是资深开发者，洛谷都能为你提供一个优质的编程学习和竞赛平台。以后我将会在洛谷上找难题，将题解发布到CSDN上，望大家多多支持。
[学习笔记]圆方树
weixin_34043301的博客
11-30 131
圆方树：元芳你怎么看 圆方树推荐 仙人掌&圆方树学习笔记 圆方树是什么？ Tarjan家族中，最不好处理的是点双 因为一个割点可能属于很多的DCC。 为了把图缩成一棵树，我们不得不做出这样的处理： 摘自：https://blog.csdn.net/qq_39670434/article/details/81973923 这个树不但丑。而且，对于一个点双...
圆方树
yzyyylx的博客
09-03 334
解释 对每一个点双新建一个方点，由这个方点向点双中的每一个点连一条新边，新边构成的新图即为圆方树，可以发现这张图必然是一棵树（如果原图不连通就是森林）。 可以发现，圆方树中任意两个圆点和任意两个方点之间都没有边。 圆方树可以用于处理图的问题，方点可以用于存储所有与它相连的圆点的信息（有时候存储部分，据题目而定）。 代码 void dfs(int now) { int p,q,t;...
【知识小结】圆方树 && 广义圆方树
执子之手,与子偕老
04-12 584
例题 杂事：datamaker 感觉仙人掌好难造，我是在树上随机加边 #include<bits/stdc++.h> using namespace std; #define rep(i,l,r) for(register int i = l ; i <= r ; i++) #define repd(i,r,l) for(register int i = r ; i >=...
20200804 专题：仙人掌（圆方树）
hongkongreporter
08-04 409
总览： 无向仙人掌图的定义： 任意一条边至多只出现在一条简单回路的无向连通图称为仙人掌。 处理方法： 建立圆方树 圆方树的建点： 原图中的点都是圆点 对于每个点双连通分量，新建一个方点，这个方点和环上其它圆点连成菊花图 对于不在环上的两个圆点，保留原图中的边 根据仙人掌的性质，易证不存在相邻的两个方点 边 (u,v)(u,v)(u,v) 权值的确定： 若 u,vu,vu,v 都是圆点，则权值为原图中边权 若 uuu 为方点，则权值为 vvv 到 uuu 父亲的最短路 感性理解： 对于图中每一个
仙人掌&圆方树学习笔记+简单应用
maxtir的博客
10-21 877
仙人掌&amp;amp;amp;amp;amp;amp;amp;圆方树学习笔记 推荐链接 ：戳这里 定义:仙人掌 任意一条边至多在一个环里的无向图 定义:仙人掌的圆方树 仙人掌 G=(V,E)G = (V, E)G=(V,E)的圆方树T=(VT,ET)T = (V_T , E_T)T=(VT​,ET​)为满足以下条件的无向图: VT=RT∪ST,RT=V,RT∩ST=∅V_ T = R_ T ∪ S_ T , R_ T = V, R_ T ∩ ...
仙人掌&圆方树学习笔记
ViXbob的博客
07-06 323
1.什么是仙人掌 给你一张无向图，一条边最多只在一个简单环当中的图被称之为仙人掌，例如： (图片源于网络) 2.什么是圆方树 仙人掌G=(V,E)G = (V, E)G=(V,E) 的圆方树 T=(VT,ET)T = (V_T,E_T)T=(VT​,ET​) 为满足以下条件的无向图： VT=RT⋃ST,RT=V,RT⋂ST≠∅V_T = R_T \bigcup S_T, R_T = V , R...
【模板】静态仙人掌(圆方树)
weixin_34167043的博客
03-16 263
传送门 Description 给你一个有\(n\)个点和\(m\)条边的仙人掌图，和\(q\)组询问 每次询问两个点\(u,v\)，求两点之间的最短路。 Solution 建出原图的圆方树，在这题中，两个点所组成的联通分量不是双联通分量 对于一条边\(<u,v>\) \(u,v\)都是圆点，则边权为原图边权 父亲节点是方点，子节点是圆点，则边权是子节点到父亲的父亲圆...
模板：圆方树
BUG_Creater_jie的博客
12-06 262
解决一般图上的连通性和路径交并等问题
【CF487E】Tourists（圆方树）
小蒟蒻yyb的博客
05-27 343
题面 UOJ 题解 首先我们不考虑修改，再来想想这道题目。 我们既然要求的是最小值，那么，在经过一个点双的时候，走的一定是具有较小权值的那一侧。 所以说，我们可以让所有的方点表示它所在的点双的最小权值， 这样子只需要对于圆方树树链剖分之后维护链的最小值就行了。 好的，回归带修改，无非是要动态的维护一下方点的最小权值了。 你问我怎么动态维护若干个值的最小值？搞个multisetm...
浅谈圆方树
Caristra的博客
08-03 679
圆方树 简介： 在运用tarjan先将连通图缩点、求出点双后，为了方便后续的操作，特别是解决维护每个点双的信息，这是尤为重要的。 那么，我们现在就直奔这个目的（维护点双），特地为每个点双再独立建新点，也就是方点，则原来的点为圆点，那么生成的图就叫圆方树… 常规操作： 在求点双的过程中，每个方点与栈内的圆点相连，最后该点双的根节点与方点相连。 不难发现，圆方树中每个方点只与圆点相...
仙人掌问题与圆方树在信息技术领域的应用
圆方树是一种数据结构，能有效地存储和操作仙人掌图，特别是处理环上的信息。它不仅可以用于解决静态的仙人掌问题，如DP、最短路、链剖分等，还能应用于动态仙人掌和动态k仙人掌问题。 在另一篇论文"关于数列递归式...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值