洛谷-Directed Roads-(基环树总结)

已于 2022-09-05 21:43:02 修改
阅读量312 收藏
点赞数 1
分类专栏： 图论 文章标签： 图论 算法
于 2022-09-05 15:30:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52398496/article/details/126706022
版权

基环树性质：
1.n点n边。
2.一般都是每个点必然有个出边，因为这样才能保证每个连通块都是一个环。
3.如果是一个连通块话的话，必然有一个环
4.对于找环的大小，如果无向图并且不能忽略重边，那么建立单向边并且用第一种类型dfs求环大小。如果有向图，那么强连通缩点求大小。
5.对于求环的某条边，一般求某一条边就够了，用并查集求。

CF711D

题意：
就是给你一个n点n边的图，然后你可以让每条边定一个方向，使得这个图没有环。问你方案数同时取模。

思考：

  1. n点n边明显基环树，如果这个图是联通的那么肯定就一个环，如果不联通可能就是多个联通块，不过每个联通块只有一个环的时候才是基环树森林。这个题保证了每个点必然会有边，所以一个联通块最多有一个环。
  2. 既然定义方向后没有环，那么对于一个环而言，只有一种顺时针的和一种逆时针的不行，然后剩下的形式都可以。所以求出来每个环的方案数，然后对于那些不是环的边就是随意了。那么方案树就明显了。
  3. 但是要注意的是，这里是给你无向的边，但是重边是有意义的，所以这里dfs求环的时候是一种方式。但是之前做的那题：2019秦皇岛-Forest Program，这题也是给你无向边让你求出来环，但是重边没有意义，dfs求环的时候是另一种方式。以上都是讨论无向图的，那么对于有向图怎么求环？用第一种dfs类型可以，也可以强连通缩点求，只要这个环的大小>=2那么就是可以的。

代码：

#include<bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define db double
#define int long long
#define PII pair<int,int >
#define mem(a,b) memset(a,b,sizeof(a))
#define IOS std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);

using namespace std;
const int mod = 1e9+7,inf = 1e18;
const int N = 2e5+10,M = 2010;

int T,n,m,k;
int va[N];
int siz[N],vis[N];

vector<int > v;
vector<int > e[N];

void dfs(int now,int p)
{
	vis[now] = 1;
	siz[now] = siz[p]+1;
	for(auto spot:e[now])
	{
		if(!vis[spot]) dfs(spot,now);
		else if(vis[spot]==1) v.pb(siz[now]-siz[spot]+1);
	}
	vis[now] = 2;
}

int ksm(int a,int b)
{
	int sum = 1;
	while(b)
	{
		if(b&1) sum = sum*a%mod;
		a = a*a%mod;
		b >>= 1;
	}
	return sum;
}

signed main()
{
	IOS;
	cin>>n;
	for(int i=1;i<=n;i++)
	{ 
		cin>>va[i];
		e[va[i]].pb(i);
	}
	int ans = 1;
	for(int i=1;i<=n;i++)
	{
		if(!vis[i]) dfs(i,0);
	}
	int sum = 0;
	for(auto t:v)
	{
		sum += t;
		ans = ans*(ksm(2,t)-2)%mod; //只有两种方式不行
	}
	ans = ans*ksm(2,n-sum)%mod; //剩下的随便
	ans = (ans%mod+mod)%mod;
	cout<<ans;
	return 0;
}
无向图不忽略重边
e[a].pb(b)建立单向边
void dfs(int now,int p)
{
	vis[now] = 1;
	siz[now] = siz[p]+1;
	for(auto spot:e[now])
	{
		if(!vis[spot]) dfs(spot,now);
		else if(vis[spot]==1) v.pb(siz[now]-siz[spot]+1);
	}
	vis[now] = 2;
}
无向图忽略重边
e[a].pb(b);
e[b].pb(a);建立双向边
void dfs(int now,int p)
{
	col[now] = 1;
	siz[now] = siz[p]+1;
	for(auto spot:e[now])
	{
		if(spot==p) continue;
		if(!col[spot]) dfs(spot,now);
		else if(col[spot]==1) v.pb(siz[now]-siz[spot]+1);
	}
	col[now] = 2;
}
有向图忽略重边：
e[a].pb(b)建立单向边
强连通缩点后，找出所有环的大小>=2的即可

洛谷-P1453 城市环路

题意：
就是给你n个点n条边，保证这个图联通，然后每个点有个人流量，小A想在某些点开店，但是一条边的两个端点不能同时开店。第i个点开店的带来的价值是va[i]*k，k是一个实数。现在问你小A最大可以获得的价值。

思考：

  1. 假如是n点n-1条边，也就是一个树的话，那么就是经典的没有上司舞会那题。但是这个多了一条边，也就是多了那个环。这不能树上跑dp了。但是实际上就这一个环，我完全可以把这个环的某个点断开分两种情况讨论。
  2. 比如断开的边的两个点分别是A,B，那么我完全可以从A开始跑dp，但是我要保证B不选，这样最后的答案就是max(A选B不选，A不选B不选)，保证了树的dp，还保证了A和B这条边没违规。怎么保证不选B呢？完全可以让va[B] = -inf就可以了。同理从B开始跑dp，va[A] = -inf一样。
  3. 然后有个疑惑点就是，一个环有好几个边，为什么我就讨论去掉其中某一条边就可以了？因为你去掉其中一条边，讨论了两种情况，保证了这条边的合法性。对于剩下的边就是一个dp，这个dp包含了所有情况。所以你求出来就是所有的情况了。就算你这个环的所有边都讨论一次答案也是一样的。和之前做过的UPC那题一样：UPC-Cards,断环成链即可，只要讨论第一个点要不要和最后一个点相连的情况然后dp就可以了。

代码：

#include<bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define db double
#define int long long
#define PII pair<int,int >
#define mem(a,b) memset(a,b,sizeof(a))
#define IOS std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);

using namespace std;
const int mod = 1e9+7,inf = 1e18;
const int N = 2e5+10,M = 2010;

int T,n,m,k;
int va[N];
int acc[N];
int dp[N][2];
int A,B;

vector<int > e[N];

int find(int x)
{
	if(x!=acc[x]) acc[x] = find(acc[x]);
	return acc[x];
}

void dfs(int now,int p)
{
	dp[now][1] = va[now];
	for(auto spot:e[now])
	{
		if(spot==p) continue;
		dfs(spot,now);
		dp[now][1] += dp[spot][0];
		dp[now][0] += max(dp[spot][1],dp[spot][0]);
	}
}

int solve1()
{
	int tp = va[B];
	va[B] = -inf;
	for(int i=1;i<=n;i++) dp[i][0] = dp[i][1] = 0;
	dfs(A,0);
	va[B] = tp;
	return max(dp[A][0],dp[A][1]);
}

int solve2()
{
	int tp = va[A];
	va[A] = -inf;
	for(int i=1;i<=n;i++) dp[i][0] = dp[i][1] = 0;
	dfs(B,0);
	va[A] = tp;
	return max(dp[B][0],dp[B][1]);
}

signed main()
{
	IOS;
	cin>>n;
	for(int i=1;i<=n;i++) acc[i] = i;
	for(int i=1;i<=n;i++) cin>>va[i];
	for(int i=1;i<=n;i++)
	{
		int a,b;
		cin>>a>>b;a++,b++;
		int t1 = find(a),t2 = find(b);
		if(t1==t2) //要去掉成环的那个条边
		{
			A = a,B = b;
			continue;
		}
		acc[t1] = t2;
		e[a].pb(b);
		e[b].pb(a);
	}
	int maxn = 0;
	maxn = max(maxn,solve1());
	maxn = max(maxn,solve2());
	db tp;cin>>tp;
	db ans = maxn*tp;
	printf("%.1lf",ans);
	return 0;
}

P2607 骑士

题意：
就是给你n个骑士，每个骑士有个自己的能力值和他讨厌的人。现在让你选择一些骑士，这些骑士之间不能有自己讨厌的人。问你选出所有骑士的最大战斗力。

思考：

  1. 这题和上题一样，一条边的两个点不能同时选，经典的没有上司的舞会。但是这个图不一定是联通的，但是保证了每个点必然有一条边，所以每个连通块必然是一个环。然后对每个环段环跑dp就可以了。
#include<bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define db double
#define int long long
#define PII pair<int,int >
#define mem(a,b) memset(a,b,sizeof(a))
#define IOS std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);

using namespace std;
const int mod = 1e9+7,inf = 1e18;
const int N = 1e6+10,M = 2010;

int T,n,m,k;
int va[N];
int acc[N];
int dp[N][2];
int vis[N],st[N],A,B;

vector<int > e[N];

int find(int x)
{
	if(x!=acc[x]) acc[x] = find(acc[x]);
	return acc[x];
}

void get(int now,int p)
{
	vis[now] = 1;
	if(st[now])
	{
		if(A==-1) A = now;
		else B = now;
	}
	for(auto spot:e[now])
	{
		if(!vis[spot]) get(spot,now);
	}
}

void dfs(int now,int p)
{
	dp[now][0] = 0,dp[now][1] = va[now];
	for(auto spot:e[now])
	{
		if(spot==p) continue;
		dfs(spot,now);
		dp[now][1] += dp[spot][0];
		dp[now][0] += max(dp[spot][0],dp[spot][1]);
	}
}

int solve1()
{
	int tp = va[B];
	va[B] = -inf;
	dfs(A,0);
	va[B] = tp;
	return max(dp[A][0],dp[A][1]);
}

int solve2()
{
	int tp = va[A];
	va[A] = -inf;
	dfs(B,0);
	va[A] = tp;
	return max(dp[B][0],dp[B][1]);
} 

signed main()
{
	IOS;
	cin>>n;
	for(int i=1;i<=n;i++) acc[i] = i;
	for(int i=1;i<=n;i++)
	{
		int a,b;
		cin>>a>>b;
		va[i] = a;
		int t1 = find(i),t2 = find(b);
		if(t1==t2)
		{
			st[i] = st[b] = 1; 
			continue;
		}
		acc[t1] = t2;
		e[i].pb(b);
		e[b].pb(i);
	}
	int ans = 0;
	for(int i=1;i<=n;i++)
	{
		if(!vis[i])
		{
			A = -1,B = -1;
			get(i,0);
			ans += max(solve1(),solve2());
		}
	}
	cout<<ans;
	return 0;
}

ABC-F - Well-defined Path Queries on a Namori

题意：
就是给你一个n个点n条边的连通图，然后给你m次询问，问你a和b两个点之间的简单路径是否唯一。

思考：

  1. 很明显就是基环树，我可以直接把这个环给断掉，拿出其中两个端点A,B，让其中一个当根节点跑一边dfs，那么这个环的所有点就是从B点往上爬直到根节点A。
  2. 这个所有环上的点也就成了一条链，然后每次给a和b，问是否有不同的路径。刚开始我总想根据a和b的lca来判断，但是画画图发现，并不是这样而且还情况多复杂。实际上就对于每个环上的点，看看他的所有孩子节点都是什么，给他标志上自己的颜色。那么对于两个点是否有多个路径，那么就看看a和b是否在一个子树上，如果不在，那么就有第二条路径。
  3. 当然只要能画图模拟出找到这个环，对环上的点的子树去染色。这个环还有种方法，可以拓扑序一直把度为1的删掉，最后剩下的就是环上的点，不过这要保证只有一个环，要不然你不知道剩下的点是在那个环里面。
  4. 一个重要的利器还是画图，只要图多画画，一会就把清理考虑清楚了。
#include<bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define db double
#define int long long
#define PII pair<int,int >
#define mem(a,b) memset(a,b,sizeof(a))
#define IOS std::ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);

using namespace std;
const int mod = 1e9+7,inf = 1e18;
const int N = 2e5+10,M = 2010;

int T,n,m,k;
int va[N];
int acc[N][25],dep[N],cnt=22;
int fa[N],vis[N],col[N],A,B;

vector<int > e[N];

int find(int x)
{
	if(x!=fa[x]) fa[x] = find(fa[x]);
	return fa[x];
}

void dfs(int now,int p)
{
	acc[now][0] = p;
	dep[now] = dep[p]+1;
	for(auto spot:e[now])
	{
		if(spot==p) continue;
		dfs(spot,now);
	}
}

void get(int now,int p,int best)
{
	col[now] = best;
	for(auto spot:e[now])
	{
		if(spot==p||vis[spot]) continue; //不能走是环上的点
		get(spot,now,best);
	}
}

signed main()
{
	IOS;
	cin>>n;
	for(int i=1;i<=n;i++) fa[i] = i;
	for(int i=1;i<=n;i++)
	{
		int a,b;
		cin>>a>>b;
		int t1 = find(a),t2 = find(b);
		if(t1==t2)
		{
			A = a,B = b;
			continue;
		}
		fa[t1] = t2;
		e[a].pb(b);
		e[b].pb(a);
	}
	dfs(A,0);
	int now = B;
	while(now)
	{
		vis[now] = 1;
		now = acc[now][0];
	}
	for(int i=1;i<=n;i++)
	{
		if(vis[i]) get(i,0,i); //给环上每个点的子树分配颜色
	}
	cin>>m;
	while(m--)
	{
		int a,b;
		cin>>a>>b;
		if(col[a]!=col[b]) cout<<"No\n";
		else cout<<"Yes\n";
	}
	return 0;
}
可爱美少女
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
基环树(环套树) 总结
glorious_dream的博客
08-16 3380
基环树(环套树) 总结
POI2008 BZOJ 1116 CLO -并查集-基环树
Mys_C_K的博客
04-25 605
题目链接：右转进入题目 题目大意：给定一个无向图，选择若干条边，并变成有向的，使每个点的入度为1. 题解：因为最后是有向图，点的入度=1意味着图的入度为n意味着图的出度=n意味着图的度为2n意味着图中有n条边意味着这是个基环树森林。 显然对于每一个联通块，都检查是否能组成基环树即可。 显然如果组成基环树，那么一定有符合题目要求的做法。 则么检查呢？非常简单。先生成这个联通块的生成树（有块
弹飞大爷 BZOJ4764 LCT维护内向基环树森林
weixin_34081595的博客
07-13 99
https://winniechen.cn/?p=99 转载于:https://www.cnblogs.com/Winniechen/p/9302972.html
学习笔记-基环树入门
caoyang1123的博客
10-15 1044
定义：多一条边的树。 性质：有一个环，删掉这环的任意一条边就可以变成树。 题目做法：一般先求出环，然后把处理这个环上每一个节点的子树，最后处理这个环。 模板题：给定一棵基环树，边带权，求直径。 做法1：刚开始没有接触过基环树的问题，所以不知道怎么搞，不过乱搞一波后发现nlogn是可写的。首先，dfs找到基环树的那个环，然后处理环上每个点的子树，维护这个子树里的最长链和次长链，更新答案。然后...
【洛谷 P5022】旅行【图论（基环树）】
在人间贩卖声音
09-28 167
解题思路 按照数据，分类讨论n-1=m和n=m的情况。 对于树上的情况（n=m），题目暗含条件：当我们到达一个点时，我们必须遍历完它的整个子树才能后退然后去到别的点。 此时，我们可以用vector来存储它的所有边然后按这条边的终点的编号从小到大排一下序，这样就可以保证字典序最小了。于是，我们用一个dfs按顺序遍历每一个节点，在dfs过程中把它们压入ans数组中，最后输出ans数组就可以了。 后四个子任务n=m，而整个图又是联通的，这说明，这个图是一个基环树。 基环树：可以理解成在一棵树上的两个节点...
force-directed-graphs:C＃中的力导向图可视化
05-20
在提供的压缩包文件“force-directed-graphs-master”中，可能包含了源代码、资源文件以及项目的配置信息。源代码可能展示了如何在C#环境中实现力导向图的各个部分，包括数据结构、力的计算、布局算法和图形渲染。...
1_Decision-Directed_actuallyrsq_谱减法_
10-04
在标题中提到的"Decision-Directed actuallyrsq"可能是指在实施谱减法时采用的一种决策导向的策略，它通常用于自适应滤波器的更新，以优化噪声估计并减少失真。 在描述中提到了"MMSE-LOGSTSA"，这是最小均方误差...
force-directed:高效的3D力导向图演示
04-28
在这个名为"force-directed"的项目中，作者采用C#语言实现了高效的3D力导向图演示。以下是关于这个项目及其相关知识点的详细说明： 1. **C#编程语言**：C#是Microsoft开发的一种面向对象的、类型安全的编程语言，...
demo-dfs-directed.rar_DEMO
09-22
- **拓扑排序**：在有向无环图（DAG, Directed Acyclic Graph）中，DFS可以用于生成一种线性顺序，使得如果存在一条从i到j的路径，那么在排序中i总是在j之前。 - **寻找连通组件**：在图中，DFS可以确定两个节点是否...
d3-force-directed-train-map
05-20
偏远岛屿火车地图d3方向力地图设置Git克隆存储库（或将压缩文件夹解压缩）到本地计算机在浏览器中打开index.html以查看地图或者只是挑战性我以前曾与d3一起使用过简单的绘图图，饼图，条形图从未使用过更高级的d3...
洛谷日报索引
热门推荐
王俊吉的博客
02-16 8万+
2022 年洛谷日报索引 2月 #383 [159号程序员] CSP初赛知识点梳理 https://www.luogu.com.cn/blog/334586/csp-pre-knowledge #382 [xtx1092515503] 群论学习笔记 https://www.luogu.com.cn/blog/Troverld/qun-lun-xue-xi-bi-ji #381 [Alpha1022] 浅谈集合幂级数 https://www.luogu.com.cn/blog/your-alpha1022/q
洛谷p1399(基环树）
cat_pikapikapi的博客
05-22 407
题意：给你一个只有一个环的图，让你选一个点（可以在边上），使得到最远点的最短路最小。 思路： 如果是一颗树的话，就是求树的直径/2。 如果是基环树的话，这道题显然不是基环树的直径，因为是到最远点的最短路的缘故。 那我们考虑最终解到其他所有点的最短路中，一定没有环，所以一定是一棵树。 所以我们枚举基环树所有可能出现的树，即枚举在环上去一条边，求树的直径。 显然最后，我们需要得到的很多解中...
【NOIP2018】【洛谷P5022】旅行【基环树】
stoorz
12-13 701
基环树的第一道题。 NOIP2018 DAY2T1
基环树DP
weixin_30266885的博客
12-25 60
一般的树形DP都是满足N个点N-1条边的数。可是有一类问题是N个点N条边，这样一定会有环，这样的图就叫基环树。 对于这类题，我们可以先dfs一次，找出环，然后把环上的一条边删除。那么图就能变成树，套用树规很容易解决。 ​ 假设将要删去的环上的边为E，边上两端点为u，v。然后分别以u和v为树根做一次DP，去最优值就可以了。 Tips：在存图是，可将cnt的初始值设为1，即第一...
【基环树】洛谷_5022 旅行
GOODPLACE
03-01 299
题意 给出一张图，选择任意一个点为起点，每次遍历只能走没经过的点，求出一个遍历顺序使得它字典序最小。 思路 首先选111为起点。 这张图有树和基环树两种情况。 树的情况下，直接贪心每次遍历编号小的点就好了。 基环树的情况，因为图中有环，所以会影响答案，不能使用贪心去做。因为题目数据很小，所以我们可以暴力删除基环树上的边，使得这个基环树变成一棵树，然后再用贪心更新答案。 代码 #include&lt...
「学习笔记」基环树
_Gion
08-26 9597
基环树是一种图，它由一个环组成，环上每个点都是一棵树点树根，所以称为基环树。当然，一棵树上连一条边也会变成基环树。 下图是一个基环树. 基环树一般分成环和树来分别处理（显然环的处理较为麻烦），那首先得找到环. 找环 大概就是dfs一下，找到一个在此结点之前走过的相邻结点就开始记录环. vector&amp;amp;amp;lt;int&amp;amp;amp;gt; G[MAXN]; //基环树 int fa[MAXN]; ...
树形dp小总结（换根，基环树，杂七杂八的dp）
sophilex的博客
07-28 488
脑子是个好东西，可惜我有的不多。。。从小到大都是看见树就头皮发麻，前阵子学的多了稍微好一点，但是经过一个树专题的洗礼，熟悉的恐惧感又回来了。。。会讲一下换根dp，基环树dp，也许后面还会更一下树上背包之类的换根换根，就是对不同节点做根的情况进行讨论，通常就是在一些节点选择的题目里会出现，但是碰到的不多（lwh简单的不会考，难的，你们。。。.....................
【洛谷P4949】最短距离【树剖】【基环树】
stoorz
10-24 451
题目大意： 题目链接：https://www.luogu.org/problem/P4949 给出一个NNN个点NNN条边的无向连通图。 你需要支持两种操作： 修改 第xxx条边的长度为yyy 查询 点xxx到点yyy的最短距离 共有MMM次操作。 思路： 第一道没有看题解写出来的黑题祭。果然还是tcltcltcl 这道题给出的图是一棵基环树，先考虑如果是一棵树应该如何处理。 显然一棵树的时...
洛谷P5022 旅行（基环树+断环法）
我们都有光明的未来
11-29 196
原题链接 题意： 一棵树，从1出发，每到达一个新的点就记录下编号。求一种走法使得记录下来的编号字典序最小。 思路： 题意里说m<=n，就说明这棵树可能是基环树。 如果这棵树是普通的树的话，直接排序后dfs一下，每次都走字典序最小的点。如果这棵树是基环树的话，首先要明确一个性质，环上肯定有一条边是不经过的，可以手动模拟一下过程。所以我们就可以每次枚举这条不经过的边，求答案后取字典序最小。这条边不经过的话，对答案是无影响的，可以确保正确性。 复杂度大概n*n，吸吸氧气就能过。 代码： const int
vt-directed-io-spec.pdf
最新发布
08-08
vt-directed-io-spec.pdf是一个文件，具体内容是关于VT引导IoT设备的指南。VT（Virtualization Technology）是一种虚拟化技术，可以帮助将物理设备虚拟化，并提供更好的管理和安全性。 这个文件主要介绍了如何使用...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值