基环树总结

最新推荐文章于 2024-04-21 21:04:00 发布
最新推荐文章于 2024-04-21 21:04:00 发布
阅读量906 收藏 7
点赞数
分类专栏： 算法 文章标签： 图论 算法 基环树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ZhuRanCheng/article/details/131736222
版权

基环树

一、定义

基环树是一个由 n n n 个点及 n n n 条边组成的联通图，其比树多出一条边，所以称作基环树；

存在多颗基环树即基环树森林，不一定保证多颗基环树之间连通；

有向基环树又分为 内向基环树 和 外向基环树；

内向基环树，即每个点出度为 1 的基环树，外向基环树，即每个点入度为 1 的基环树；

对于有关基环树问题，一般有两种解决方式，

  1. 将环上的每个节点作为根，先计算其子树贡献，再将其贡献放入环中；
  2. 将环断开一条边，则作普通树处理；

二、找环

1. tarjan 算法

搜索每个节点，标记节点的 DFN 值，并记录每个结点的前驱；

若搜索到一条返祖边，则从当前节点沿前驱节点回溯至边的另一端点，则回溯路上的所有节点均为环上的节点；

vector <edge> g[MAXN];
int dfn[MAXN], cnt, fa[MAXN], loop[MAXN], len;
void dfs_loop(int i) {
	dfn[i] = ++cnt;
	for (int t = 0; t < g[i].size(); t++){
		int v = g[i][t];
		if (v == fa[i]) continue;
		if (!dfn[v]) {
			fa[v] = i;
			dfs_loop(v);
		} else {
			if (dfn[v] < dfn[i]) continue; 
			loop[++len] = v;
			for (; v != i; v = fa[v]) loop[++len] = fa[v];
		}
	}
}

2. 拓扑排序

记录每个节点的度数，进行拓扑排序；

则入度 ≥ 2 \geq 2 ≥2 的点即为环上的点；

则拓扑排序后度数不为 0 的节点即为环上的点；

void topo_loop() {
	queue <int> q;  
	for (int i = 1; i <= n; i++) {
		if (de[i] == 1) q.push(i);
	}   
    while (!q.empty()) {
        int i = q.front();
		q.pop();
        for (int t = 0; t < g[i].size(); t++) {
            int v = g[i][t];
			if (de[v] > 1) {
            	de[v]--;
            	if (de[v] == 1) q.push(v);
			}
        }
    }
    return;
}

三、题目

骑士

1. 题目

有 n n n 个人，每个人有一个最恨的人，若最恨的人加入任务，则自己一定不会加入任务，现给出每个人的战斗力值，求战斗力值总和最大值；

2. 分析

可以发现，若此题为一棵树，及只有 n − 1 n - 1 n−1 条边，则可使用树形 DP 解决；

定义 d p [ i ] [ 0 / 1 ] dp[i][0/1] dp[i][0/1] 表示以 i i i 为根的子树，且 i i i 号节点不选 / 选的时战斗力最大值；

则当 i i i 不选时，其子节点可选可不选；

当 i i i 选时，则其子节点一定不能选；

有状态转移方程，
d p [ i ] [ 0 ] = ∑ m a x ( d p [ v ] [ 0 ] , d p [ v ] [ 1 ] ) d p [ i ] [ 1 ] = ∑ d p [ v ] [ 0 ] dp[i][0] = \sum max(dp[v][0], dp[v][1]) \\ dp[i][1] = \sum dp[v][0] dp[i][0]=∑max(dp[v][0],dp[v][1])dp[i][1]=∑dp[v][0]
先考虑基环树上做法；

则考虑对于基环树上相比原树的多出的一条边，此边上的两点是肯定无法同时选的；

所以可将此边断开，并强制此边上的两点中一点不选，并以另一点为根进行树上 DP，最后取最大值即可；

3. 代码
#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm> 
using namespace std;
const int MAXN = 1000005;
const int INF = 2147483647;
int n;
long long a[MAXN], v[MAXN];

vector <int> g[MAXN];

bool flag[MAXN];
int r;
void dfs_loop(int i){
	flag[i] = true;
	if (flag[v[i]]) r = i;
	else dfs_loop(v[i]);
	return;
}

long long dp[MAXN][2], tot = -1, ans = 0;
void dfs(int i) {
	dp[i][0] = 0, dp[i][1] = a[i];
	flag[i] = true;
	for (int t = 0; t < g[i].size(); t++) {
		int v = g[i][t];
		if (v == r) {
			dp[v][1] = -INF;
			continue;
		}
		dfs(v);
		dp[i][0] += max(dp[v][1], dp[v][0]);
		dp[i][1] += dp[v][0];
	}
	return;
}

int main() {
	scanf("%d", &n);
	for (int i = 1; i <= n; i++) {
		scanf("%lld %d", &a[i], &v[i]);
		g[v[i]].push_back(i);
	}
	
	
	for (int i = 1; i <= n; i++) {
		if (!flag[i]) {
			dfs_loop(i); // 找环上边
			dfs(r); // 断边 DP
			tot = max(dp[r][0], dp[r][1]);
			r = v[r];
			dfs(r);
			ans += max(tot, max(dp[r][0], dp[r][1]));
		}
	}
	printf("%lld\n", ans);
	return 0;
}

Island

1. 题目

给定一个基环树森林，求每颗基环树直径之和；

2. 分析

若对于一棵树，可通过搜索得到每个节点的向下最长路和次长路，相加即为经过该节点的最长路，计算经过每个点最长路后比较最大值即可；

考虑有环情况，

可发现，直径有三种情况；

  1. 直径为经过环上一点的最长路，而不经过环上的边；
  2. 直径为经过环上的边，即为 环上一点的向下最长路 + 环上另一点的向下最长路 + 两点间的距离；

对于情况一，以环上每个节点为根，进行 DP 即可；

对于情况二，即

找到 d p [ i ] + d p [ j ] + d i s [ i ] [ j ] dp[i] + dp[j] + dis[i][j] dp[i]+dp[j]+dis[i][j] 的最大值；

直接枚举会超时，所以可以维护一个前缀和，问题转化为；

d p [ i ] + d p [ j ] + s u m [ i ] − s u m [ j ] dp[i] + dp[j] + sum[i] - sum[j] dp[i]+dp[j]+sum[i]−sum[j] 的最大值；

则可维护 s u m [ j ] − d p [ j ] sum[j] - dp[j] sum[j]−dp[j] 最小值，然后直接枚举 i i i 即可；

使用单调队列；

3. 代码
#include <cstdio>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;
const int MAXN = 2000005;
int n;
long long sum[MAXN], ans = 0, tot;

struct edge {
	int to;
	long long tot;
};
vector <edge> g[MAXN];
int dfn[MAXN], cnt, fa[MAXN], loop[MAXN], len;
void dfs_loop(int i) {
	dfn[i] = ++cnt;
	for (int t = 0; t < g[i].size(); t++){
		int v = g[i][t].to;
		if (v == fa[i]) continue;
		if (!dfn[v]) {
			fa[v] = i;
			dfs_loop(v);
		} else {
			if (dfn[v] < dfn[i]) continue; 
			loop[++len] = v;
			for (; v != i; v = fa[v]) loop[++len] = fa[v];
		}
	}
}
long long path, dp[MAXN];
bool flag[MAXN];
void dfs(int i) {
	flag[i] = true;
	for (int t = 0; t < g[i].size(); t++) {
		int v = g[i][t].to;
		long long tot = g[i][t].tot;
		if (!flag[v]) {
			dfs(v);
			path = max(path, dp[i] + dp[v] + tot);
			dp[i] = max(dp[i], dp[v] + tot);
		}
	}
	return;
}

int q[MAXN], l, r;
int main() {
	scanf("%d", &n);
	for (int i = 1; i <= n; i++) {
		int y;
		long long z;
		scanf("%d %lld", &y, &z);
		g[i].push_back(edge({y, z}));
		g[y].push_back(edge({i, z}));
	}
	
	for (int s = 1; s <= n; s++) {
		if (!flag[s]) {
			cnt = len = 0;
			
			dfs_loop(s);
			
			tot = 0;
			
			for (int i = 1; i <= len; i++) flag[loop[i]] = true;
			
			for (int i = 1; i <= len; i++) {
				int v = loop[i];
				path = 0ll;
				dfs(v);
				tot = max(tot, path); // 情况 1
			}
			
			loop[0] = loop[len];
			for (int i = 1; i <= len; i++) {
				int v = loop[i];
				long long val = -1ll;
				for (int j = 0; j < g[v].size(); j++) {
					if (g[v][j].to == loop[i - 1]) val = max(val, g[v][j].tot);
				}
				sum[i] = sum[i - 1] + val; // 记录环上前缀和
			}
			for (int i = 1; i < len; i++) sum[i + len] = sum[len] + sum[i]; // 环，复制一份前缀和

			l = r = 1;
			q[1] = 0; // 单调队列维护 sum[i] - dp[i]
			for (int i = 1; i < len * 2; i++) {
				while (l <= r && q[l] <= i - len) l++;
				tot = max(tot, sum[i] - sum[q[l]] + dp[loop[q[l] % len]] + dp[loop[i % len]]);
				while (l <= r && sum[q[r]] - dp[loop[q[r] % len]] >= sum[i] - dp[loop[i % len]]) r--;
				q[++r] = i;
			}
			
			ans += tot;
		}
	}
	printf("%lld\n", ans);
	return 0;
}

RAN-Rendezvous

1. 题目

给定一颗基环树，现给定若干个 a , b a, b a,b 求满足下面条件的 x , y x, y x,y ，

  1. 从顶点 a 沿着出边走 x 步和从顶点 b 沿着出边走 y 步后到达的顶点相同；
  2. 在满足条件 1 的情况下 max(x,y) 最小；
  3. 在满足条件 1 和 2 的情况下 min(x,y) 最小；
  4. 在满足条件 1 、2 和 3 的情况下 x>=y ；
2. 分析

若对于一棵树，此题则为求两点 LCA 到其距离；

则对于基环树，可分类讨论，

  1. 若两点不在同一颗基环树上，
    输出 -1 ；

  2. 若两点在同一颗基环树上，且两点均在一颗以环上一点为根的子树里；

    直接两点 LCA 到其距离即可；

  3. 若两点在同一颗基环树上，但两点不在一颗以环上一点为根的子树里；

    则两点相遇点一定在两点所在子树的根节点之一，分别计算即可；

3. 代码
#include <cstdio>
#include <cmath>
#include <vector>
#include <queue>
#include <cstring>
#include <algorithm> 
using namespace std;
const int MAXN = 500005;
int n, q;
vector <int> g[MAXN];
int de[MAXN], root[MAXN], bel[MAXN], ro[MAXN], len[MAXN], tot = 0;
int dp[MAXN][32], log1[MAXN], dep[MAXN];
void topo_loop() { // 找环
	queue <int> q;
	for (int i = 1; i <= n; i++) {
		if (!de[i]) q.push(i);
	}
    while (!q.empty()) {
        int u = q.front();
		q.pop();
        int v = dp[u][0];
        de[v]--;
        if (!de[v]) q.push(v);
    }
    return;
}

bool flag[MAXN];
void logset() {
    log1[1] = 0;
    for (int i = 2; i <= MAXN; i++) {
        log1[i] = log1[i / 2] + 1;
    }
    return;
}
void dfs(int i, int r) {
	bel[i] = r;
    flag[i] = true;
    for (int t = 0; t < g[i].size(); t++) {
        int v = g[i][t];
        if (!flag[v] && !de[v]) {
            dep[v] = dep[i] + 1;
            dp[v][0] = i;
            for (int j = 1; j <= log1[dep[v]]; j++) {
                dp[v][j] = dp[dp[v][j - 1]][j - 1];
            }
            dfs(v, r);
        }
    }
    return;
}
int LCA(int u, int v) {
    if (dep[u] < dep[v]) swap(u, v); 
    while (dep[u] != dep[v]) { 
        u = dp[u][log1[dep[u] - dep[v]]]; 
    }
    if (u == v) return u; 
    for (int i = log1[dep[u]]; i >= 0; i--) { 
        if (dp[u][i] != dp[v][i]) {
            u = dp[u][i], v = dp[v][i]; 
        }
    }
    return dp[u][0];
}


void dfs1(int i, int num, int dep) {
	if (ro[i] != -1) return;
	root[i] = num;
	len[num]++;
	ro[i] = dep;
	dfs1(dp[i][0], num, dep + 1);
}

bool cmp(int a, int b, int x, int y) {
	if (max(a, b) != max(x, y)) return max(a, b) < max(x, y);
	if (min(a, b) != min(x, y)) return min(a, b) < min(x, y);
	return a >= b;
}

int main() {
	memset(ro, -1, sizeof(ro));
	scanf("%d %d", &n, &q);
	for (int i = 1; i <= n; i++) {
		int x;
		scanf("%d", &x);
		dp[i][0] = x;
		g[x].push_back(i);
		de[x]++;
	}
	topo_loop();
	logset();
	
	for (int i = 1; i <= n; i++) {
		if (de[i]) { // 环上节点
			dfs(i, i); // 以节点为根，预处理 LCA
			if (ro[i] == -1) dfs1(i, ++tot, 0); // 找此环信息
		}
	}
	
	
	for (int i = 1; i <= q; i++) {
		int x, y;
		scanf("%d %d", &x, &y);
		if (root[bel[x]] != root[bel[y]]) { // 情况 1
			printf("-1 -1\n");
		} else if (bel[x] == bel[y]) { // 情况 2
			int lca = LCA(x, y);
			printf("%d %d\n", dep[x] - dep[lca], dep[y] - dep[lca]);
		} else { // 情况 3
			int r1 = bel[x], r2 = bel[y];
			int tot1 = dep[x] + (ro[r2] - ro[r1] + len[root[r1]]) % len[root[r1]];
			int tot2 = dep[y] + (ro[r1] - ro[r2] + len[root[r2]]) % len[root[r2]];
			if (cmp(tot1, dep[y], dep[x], tot2)) printf("%d %d\n", tot1, dep[y]);
			else printf("%d %d\n", dep[x], tot2);
		}
	}
	return 0;
}
ZhuRanCheng
关注
  • 0
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
基环树求环基本思路
weixin_30467087的博客
05-02 1812
什么是基环树？ n条边，n个点，连在一起，就变成了基环树 基环树如何求环？ 有人用拓扑排序，但是如果不苛求时间复杂度，可以直接利用栈的思想和dfs进行找环 步骤？ 第一步：寻找（任意）一个点进行一次dfs(1,0) 第二步：将所有dfs到的点，存入到栈中 第三步：直到发现连接的点已经访问过了，这时候就相当于找到了一个环 由于dfs的特性，这个时候你只是一直访问了一个路径，一直出栈，...
基环树找环
qq_42821571的博客
02-22 952
#include&amp;lt;iostream&amp;gt; #include&amp;lt;cstdio&amp;gt; #include&amp;lt;algorithm&amp;gt; #include&amp;lt;cstring&amp;gt; #include&amp;lt;string&amp;gt; #include&amp;lt;queue&amp;gt; #include&amp;
【算法竞赛学习笔记】基环树-超有用的图论详解
SC_Linno的博客
10-29 3628
title : 基环树 date : 2021-8-29 tags : ACM,图论 author : Linno 简介 基环树是一个n个点n条边的图，比树多出现一个环，因此称为基环树。 找环 对于无向图 通过拓扑排序可以找出环上的所有点。 void topsort(){ int l=0,r=0; for (int i=1;i<=n;i++) if(in[i]==1) q[++r]=i; while(l<r) { int now=q[++.
树和基环树上两点间最短距离问题
最新发布
xuxizhe0104的博客
04-21 226
对于基环树讲，我们可以将环上的每个点都当作根节点来对其子树进行一次dfs做预处理（同普通树）并记录所属根节点，在询问时，如果两点属于同一根节点的子树，那么按照普通树的询问来处理，否则我们将环上若干个相邻的点进行编号为1……tot，那么我们就可以得到两个根之间有两个走法，第一个是dis = abs( id[ x ] - id[ y ])，第二个则是tot-dis，最后取两者最小值加上d[ x ] + d[ y ]就是最短距离了。共 q 行，每行表示一个询问的答案，即点 u 到点 v 的最短距离。
基环树学习笔记
Minecraftwzy的博客
07-10 960
只因环树学习笔只因。如有错误欢迎指出。
图论——基环树
hungry1234的博客
10-11 922
基环树，就是n个点n条边的树，因为这个图相当于在树上加了一条边，故一定会形成一个环 所以基环树上的问题大多数都是先处理以环上的点为根节点的子树的值，然后在环上做dp之类的东西 找到环是基环树上的问题的重要一步，可以记录下来每个点的时间戳，若一个点的子节点被访问过了，那么这两个点一定是环上的节点，以这两个点为首尾讲一个环找到 为了方便，当且仅当一个点的子节点被遍历过且这个点的时间戳小于它的子节点的时间戳，我们才开始记录这个环 void get_cir(int x){ dfn[x]=++times;
基环树，基环内向树，基环外向树
EQUINOX1的博客
11-01 346
如果图G是连通的，并且无回路，则称G为树。我们给树任意加一条边，就出现了环，我们称之为上面都是无向树，如果变为有向树，则可进一步分为基环内向树和基环外向树。
基环树略解
YangHao5的博客
10-23 338
基环树 基环树，也叫 环套树，是一种图的类型。如果连通图 G={V,E}G=\{V,E\}G={V,E} 有 ∣V∣=∣E∣|V|=|E|∣V∣=∣E∣，则我们称它是 基环树。 顾名思义，基环树就好似是在一棵树上加一条边得到的图。基环树有且仅有一个环，所以也被成为环套树。 如上图所示的图就是一棵基环树。 用途 基环树没什么用。 它只能解决部分特殊问题，而这类问题通常会注明“边数=点数”，解法也...
基环树 笛卡尔树--2021.09.06(E).pdf
09-06
* 基环树的小结：基环树可以用于解决基环树的小结问题，通过基环树可以快速地找到基环树的结点。 * 基环树的应用：基环树可以用于解决基环树的应用问题，通过基环树可以快速地找到问题的解答。 格雷码是一种特殊的...
基环树11111111111
07-10
【基环树】是一种特殊的图结构，通常出现在解决与树相关的算法问题中，尤其是在需要高效处理树状数据的场景下。基环树的概念源于无向图，它包含了一个环（循环），环上的每个节点同时也是各自独立树的根节点。基环树...
软基处理QC小组成果总结.doc
05-18
总结计划 计划 实际 计划时间 实际时间 制表人：李清宇 2016年4月20日 五、设定课题目标 查阅相关规范及设计图纸，确定课题目标为： 确保软基处理后路基的施工质量达到优良标准。 目标值：（1）复合地基...
科斯塔斯环总结报告.doc
10-08
科斯塔斯环总结报告 一、研究目的： 在高速移动通信系统中，收、发送机的相对运动使得接收信号不可防止地形成快衰落信道，从而引入较大的多普勒偏移和多普勒变化率，故此必须纠正或补偿多普勒频偏和多普勒变化率，...
煤基产业树构建与应用研究
06-12
文章在产业链和产业网络等理论基础上,提出煤基产业树概念,并通过类比分析方法构建了煤基产业树模型;然后,分析了煤基产业树结构与功能以及演化机理;最后,从理论和实证两方面分析了煤基产业树在区域煤炭产业转型方向...
「学习笔记」基环树
_Gion
08-26 9590
基环树是一种图，它由一个环组成，环上每个点都是一棵树点树根，所以称为基环树。当然，一棵树上连一条边也会变成基环树。 下图是一个基环树. 基环树一般分成环和树来分别处理（显然环的处理较为麻烦），那首先得找到环. 找环 大概就是dfs一下，找到一个在此结点之前走过的相邻结点就开始记录环. vector&amp;amp;amp;lt;int&amp;amp;amp;gt; G[MAXN]; //基环树 int fa[MAXN]; ...
基环树找环-模板
weixin_30379973的博客
02-13 244
#include <bits/stdc++.h> using namespace std; #define INF 0x3f3f3f3f #define MAXN 1000010 #define MAXM 5010 inline int read() { int x = 0,ff = 1;char ch = getchar(); whil...
树形dp 基环树直径 bzoj1791 ioi2008island
wbysr
03-27 2265
这个题真的好麻烦啊。。。 就是给一堆基环树然后求出他们的直径的和 我们首先不考虑环，然后对于每个点求出他所能走到的最大深度， 然后缩点，就成了一个面包圈一样的环了 然后脱环成链直接用单调队列dp就可以了 队列中维护dp的决策，由于决策是有单调性的。。。#include #include #include #include #include #define MAX
找出基环树的环c++ 使用vector存图
09-22
要找出基环树的环c，可以使用深度优先搜索（DFS）算法来实现。以下是使用vector存储图的一个示例代码： ```cpp #include <iostream> #include <vector> using namespace std; vector<bool> visited; // 记录节点是否已经访问过 vector<int> parent; // 记录每个节点的父节点 vector<bool> inCycle; // 记录节点是否在环中 vector<int> cycle; // 存储找到的环 // 深度优先搜索 bool dfs(vector<vector<int>>& graph, int node, int parentNode) { visited[node] = true; parent[node] = parentNode; for (int neighbor : graph[node]) { if (!visited[neighbor]) { if (dfs(graph, neighbor, node)) return true; } else if (neighbor != parentNode) { // 找到了环 cycle.push_back(neighbor); inCycle[neighbor] = true; int cur = node; while (cur != neighbor) { cycle.push_back(cur); inCycle[cur] = true; cur = parent[cur]; } cycle.push_back(neighbor); // 将最后一个节点加入环中 return true; } } return false; } // 找到基环树的环c vector<int> findCycle(vector<vector<int>>& graph) { int n = graph.size(); visited.resize(n, false); parent.resize(n, -1); inCycle.resize(n, false); for (int i = 0; i < n; i++) { if (!visited[i] && dfs(graph, i, -1)) break; } return cycle; } int main() { int n = 4; // 图的节点数 vector<vector<int>> graph(n); // 添加图的边 graph[0].push_back(1); graph[1].push_back(0); graph[1].push_back(2); graph[2].push_back(1); graph[2].push_back(3); graph[3].push_back(2); vector<int> cycle = findCycle(graph); // 输出环c中的节点 cout << "环c中的节点: "; for (int node : cycle) { cout << node << " "; } cout << endl; return 0; } ``` 以上代码通过深度优先搜索遍历图，当遇到一个已经访问过的节点时，如果该节点不是当前节点的父节点，则找到了一个环。然后通过记录每个节点的父节点，可以回溯找到构成该环的所有节点。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值