图论：图的环路检测和取环

已于 2022-05-09 10:04:52 修改
阅读量8.8k 收藏 16
点赞数 5
分类专栏： Algorithm 文章标签： 算法
于 2021-09-30 13:10:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/doctor_oyy/article/details/120564776
版权

图论：有向图的环路检测和取环

图的相关概念

顶点

边（有向、无向）

度（入度、出度）

一个顶点如果有一条边指向它，那我们就说这个顶点的入度为1 ；类似地，从顶点出发，有一条边我们就说这个顶点的出度为 1

图的表示

邻接矩阵

1-1

假设有 n 个顶点 m 条边的图，声明一个 m * n 的二维数组，G[i][j] = 1 表示 i → j 是连通的

但存在几个问题：

  • 遍历元素时，存在的边和不存在的边都不得不检查一遍，导致遍历效率低。
  • 不能存储重复的边。
  • 当顶点数量多时，内存空间开销会很大。
  • 空间利用率不高。
  • 存储无向图时，由于此时矩阵是对称的，而对称位置上的成对元素保存的信息是重复的，导致空间利用率不高。

邻接表

1-2

用一个数组adj存储以这个点可以到达的所有顶点，例如：adj[i] = [a, b, c, d] ，adj[i] 可以是一个链表或者数组

图的环路检测方法

并查集

并查集详解 --图文解说,简单易懂(转)

Q & A

  1. 为什么需要路径压缩？为什么可以压缩？

    最坏的情况下，查找路径可能退化成一条链，极大影响查找效率；

    pre 数组并不用存储真正的节点之间的关系，它的作用只有一个，判断任意 2 个节点有没有一个公共祖先；

    压缩的几种方式：

    1. 按秩合并
    2. 边查找边合并

  2. 什么情况下说明有环？

    将要合并的 2 个节点，它们已经拥有公共祖先的时候，说明可能存在环（注意是可能存在 ）

  3. 那什么情况下有公共祖先但是也没有环呢？

    有向图的情况，要知道有向图的边是有方向的，即使 2 个节点存在公共祖先，也不一定构成环，例如：[ [1,2], [1,3], [2,3] ]

    不过下面这道题涉及的只是无向图，因此不用特别处理。

// [https://leetcode-cn.com/problems/graph-valid-tree/](https://leetcode-cn.com/problems/graph-valid-tree/)

// Input: n = 5, edges = [[0,1],[0,2],[0,3],[1,4]]
// Output: true

// Input: n = 5, edges = [[0,1],[1,2],[2,3],[1,3],[1,4]]
// Output: false

const int maxN = 2010;
int pre[maxN];

int find(int x) {
  return x == pre[x] ? x : pre[x] = find(pre[x]); // 路径压缩，边查找边压缩
}

void _union(int x, int y) {
  int fx = find(x), fy = find(y);
  if (fx != fy) {
    pre[fx] = fy;
  }
}

class Solution {
  public:
    bool validTree(int n, vector<vector<int> >& edges) {
      for (int i = 0; i < n; i++) {
        pre[i] = i;
      }
      for (int i = 0; i < edges.size(); i++) {
        int a = edges[i][0], b = edges[i][1];
        if (find(a) == find(b)) {
          return false;
        }
        _union(a, b);
      }
			// 多个分离的树也不是一棵合法的树
      set<int> preSet;
      for (int i = 0; i < n; i++) {
        preSet.insert(find(i));
      }
      return preSet.size() == 1;
    }
};

拓扑排序

什么是拓扑关系？

举个例子，一门课程都有它的先修课程

1-3

用图的方式表示就是:

Untitled

课程之间的相互关系就是一种拓扑关系。

什么是拓扑序列，如何寻找拓扑序列？

我们知道了任意一门课程的先修课程，如果此时要你来给学生做一张大学四年的课程表，那么这种课程表中课程组成的序列实际上就是一个拓扑序列

具体做法：在有向图中，找出入度为 0 的顶点，将这些顶点放到队列中，依次删除这些顶点及其相关的边，重复上一步，就可以得到一个拓扑序列


// 拓扑排序

// input: [[1,0],[2,0],[3,1],[3,2]]
// output: [0, 1, 2, 3] or [0, 2, 1, 3]

const edges = [[1,0],[2,0],[3,1],[3,2]];

const inDegree = [];
// 求顶点的入度
edges.forEach(edge => {
  const [target, source] = edge;
  inDegree[target]++;
}

// 找出入度为 0 的顶点
let queue = [];
inDegree.forEach((val, index) => {
  if (val === 0) {
    queue.push(index)
  };
});

const res = [];

while (queue.length) {
  const cur = queue.shift();
  res.push(cur);
  edges.forEach(edge => {
    const [target, source] = edge;
    if (source === cur) {
      inDegree[target]--;
			// 新的入度为 0 的顶点，一定在这里产生
      if (inDegree[target] == 0) {
        queue.push(target);
      }
    }
  })
}

console.log(res)

如果找不到一个入度为 0 的顶点，是否就说明一定存在环？

直觉上是，不过还没找到证明方法。

如何在检测环的同时取出环？

要想取出环，意味着我们需要将整个图至少遍历一遍，比较直接的做法是深度优先遍历

算法讲解：https://www.youtube.com/watch?v=rKQaZuoUR4M

Q & A

  1. 为什么要使用 3 种颜色标记节点？

    其实相当于剪枝；color 为 2 的节点再也不必访问了

  2. pre 数组是干什么用的？

    记录节点的父节点，找到环时，从 dfs 最后一个探访的一个节点出发，依次寻找其父节点，直到形成一个环或者在中途路径断开（也就是说这个节点没有父节点了），到此为止，这个过程就在构造环

  3. 复杂度是多少？

    假设顶点数量为 V， 边的数量为 E ， 每条边都要走一遍，那么时间复杂度为 O(V+E) ，空间复杂度为 O(V) (实际上我们需要额外的空间保存环结构，所以最坏情况下占用空间应该是 cv1+cv2+…+cvv＝2^v）

  4. 存在什么隐患？

    图的层级太深会爆栈

JavaScript 版：

// [https://cses.fi/problemset/task/1678](https://cses.fi/problemset/task/1678)

// const n = 4, m = 5;
// const edges = [[1,3], [2,1], [2,4], [3,2], [3,4]];
//const n = 10, m = 20;
//const edges = [[9,8], [2,9],[7,5], [4,5],[1,5],[3,8],[4,2],[5,4],[6,5],[3,6],[8,10],[10,9],[10,7],[9,3],[7,6],[8,7],[7,3],[8,9],[7,10],[2,1]]
const n = 6, m = 7;
const edges = [[1, 2], [2, 3], [3, 1], [1, 4], [4, 6], [6, 5], [5, 4]];

const pre = Array(n + 1).fill(-1);

const color = Array(n + 1).fill(0);

// 建立邻接表
const adj = [[], [], [], [], [], [], [], [], []]; // 不知道为什么，初始化用 Array(n + 1).fill([]) 会报错
edges.forEach(edge => {
  const [source, target] = edge;
  adj[source].push(target);
});

const cycles = [];

const buildCycle = (start, end) => {
  const cycle = [start];
  for (let cur = end; cur !== start; cur = pre[cur]) {
    cycle.push(cur);
  }
  cycle.push(start);
  cycles.push(cycle.reverse());
}

const dfs = source => {
  color[source] = 1;
  adj[source].forEach(target => {
    if (color[target] === 0) {
			pre[target] = source;
      dfs(target);
    } else if (color[target] === 1) {
      // console.log(target, source)
      buildCycle(target, source);
    }
  });
  color[source] = 2;
}

for (let v = 1; v <= n; v++) {
  if (color[v] === 0) {
    dfs(v);
  }
}

console.log(cycles)

C++版：

#include<iostream>
#include<vector>
using namespace std;

const int maxN = 1e5+10;
vector<int> color(maxN, 0) , pre(maxN, 0), adj[maxN];

vector<vector<int> > res;

void build_cycle(int start, int end) {
  vector<int> cycle;
  cycle.push_back(start);
  for (int cur = end; cur != start; cur = pre[cur]) {
    cycle.push_back(cur);
  }
  cycle.push_back(start);

  vector<int> reversedCycle;
  for (int i = cycle.size() - 1; i >= 0; i--) {
    reversedCycle.push_back(cycle[i]);
  }

  res.push_back(reversedCycle);
}

void dfs(int source) {
  color[source] = 1;
  for (int &target: adj[source]) {
    if (color[target] == 0) {
      pre[target] = source;
      dfs(target);
    } else if (color[target] == 1) {
      build_cycle(target, source);
    }
  }
  color[source] = 2;
}

int main() {
  int n, m;
  cin >> n >> m;
  while (m--) {
    int a, b;
    cin >> a >> b;
    adj[a].push_back(b);
  }

  for (int i = 1; i <= n; i++) {
    if (color[i] == 0) {
      dfs(i);
    }
  }

  if (res.size() != 0) {
    for (int i = 0; i < res.size(); i++) {
      cout << res[i].size() << endl;
      for (int j = 0; j < res[i].size(); j++) {
        cout << res[i][j] << " ";
      }
      cout << endl;
    }
  } else {
    cout << "IMPOSSIBLE" << endl;
  }

  return 0;
}

并查集也可以部分实现，前面提到，对有向图，我们可以特殊处理一下，依然拿这个例子：[ [1,2], [1,3], [2,3] ], 我们首先合并[1,2], [2,3]，此时 [1,2,3]已经在一个集合中，再合并[2,3], 进入构建环的逻辑: 3 入队，再找到 2 的祖先是 1， 将 1 入队，1 的祖先不存在，不构成环，所以可以结束遍历

#include<iostream>
#include<vector>
#include<cmath>
#include<set>
#include<algorithm>
using namespace std;

const int maxN = 1e5+10;

int pre[maxN];

int pre2[maxN];

vector<vector<int> > res;

// TODO: pre2 这个一维数组并不能处理存在入度大于 1 的顶点的情况，可以改成二维，~~广搜跑一遍~~，不对应该深度优先
void buildCycle(int start, int end) {
  
  vector<int> cycle;
  cycle.push_back(start);
  for (int cur = end; cur != start; cur = pre2[cur]) {
		// 对于入度大于 1 的顶点，也会走到这里，所以需要判断一下查找过程中是不是到尽头了，到了就直接 return
    if (cur == -1) {
      return;
    }
    cycle.push_back(cur);
  }
  cycle.push_back(start);

  vector<int> reversedCycle;

  for (int i = cycle.size() - 1; i >= 0; i--) {
    reversedCycle.push_back(cycle[i]);
  }

  res.push_back(reversedCycle);
}

int find(int x) {
  // cout << "find" << x << endl;
  return x == pre[x] ? x : pre[x] = find(pre[x]); // 路径压缩，边查找边压缩
}

// 5 7
// 1 5
// 1 2
// 1 3
// 3 4
// 4 2
// 2 5
// 4 1

void _union(int x, int y) {
  if (pre2[y] == -1) pre2[y] = x;

  int fx = find(x), fy = find(y);
  if (fx != fy) {
    pre[fx] = fy;
  }
}

int main() {
  int n, m;
  cin >> n >> m;

  for (int i = 0; i <= n; i++) {
    pre[i] = i;
    pre2[i] = -1;
  }

  while (m--) {
    int a, b;
    cin >> a >> b;
    if (find(a) == find(b) ) {
      buildCycle(b, a);
      continue;
    }
    _union(a, b);
  }

  if (res.size() != 0) {
    for (int i = 0; i < res.size(); i++) {
      cout << res[i].size() << endl;
      for (int j = 0; j < res[i].size(); j++) {
        cout << res[i][j] << " ";
      }
      cout << endl;
    }
  } else {
    cout << "IMPOSSIBLE" << endl;
  }

  return 0;
}

这里有一组数据超时主要是因为，题目其实只要找一个环，我的解法为了满足业务上可能的需要，扩充了一下，找所有环，理论上改成只找到一个环就结束，应该是可以 AC 的

1-5

TODO：尚不能完美处理存在入度大于 1 的顶点的情况，需要将 pre2 变成二维，再遍历一个节点的所有父节点，目前看广搜深搜都可

应该使用深搜!! 还是不对，广搜其实可以

doctoroyy
关注
专栏目录
图中检测环算法 DFS 后向边
10-18
图论中用后向边检测环，算法导论中有介绍，这里是一个实现
2022.3.23 图论——环检测算法
LGoGoGo的博客
03-23 2451
课程表I（环检测算法）
图论——环检测
LiuRenyou的博客
01-18 1388
文章目录图论——环检测问题分析代码 图论——环检测 问题分析 检测上图是否有环其实也相当简单，只要dfs的过程发现某个顶点的邻接顶点已经访问过了，就说明有环，除此之外，还要排除一种情况，如下： 例如从0开始dfs，0已访问 dfs 1，发现1的邻接顶点0已被访问，此时不可以判定有环，即要排除已访问的顶点不是上一个顶点(parent) 代码 graph.txt 7 6 0 1 0 2 1 3 2 ...
环路检测典型配置-Loop Detection检测设备所在网络
最新发布
满地找牙的博客
07-01 1425
Loop Detection（环路检测）是一种用于识别和防止网络中形成环路的技术，它特别适用于交换机所在的网络环境。网络环路会导致数据包无休止地循环转发，从而引发广播风暴、MAC地址表不稳定、网络拥塞乃至整体网络性能的严重下降。
已知的无向图列出其中所有的简单环路_学习笔记4——因子图神经网络
weixin_39766258的博客
11-20 773
Incorporating Biological Knowledge with Factor Graph Neural Network for Interpretable Deep Learning一、基本知识1、图模型：图模型是由图结构构成的，其中节点表示随机变量，边表示变量之间的依赖关系。2、贝叶斯网络：是有向图模型，每个节点都有一个相关的条件概率分布。3、马尔可夫网络：是无向图模型，每个团都...
C语言经典算法之Tarjan算法
weixin_56154577的博客
03-07 1106
Tarjan算法是一种在图论中用于寻找有向图或无向图的强连通分量的有效算法，由Robert Tarjan于1972年提出。该算法利用深度优先搜索（DFS）的思想，并引入了两个关键数组：DFN（深度优先遍历编号）和LOW（低链接点），通过栈来追踪当前路径上的节点，并判断哪些节点属于同一个强连通分量。
判断无向图/有向图中是否存在环
weixin_30788239的博客
07-16 3395
　　本文主要针对如何判断有向图/无向图中是否存在环的问题进行简单的论述。 一 无向图 1.利用DFS进行判断 利用DFS判断有向图是否存在环，是最为常用的一种方法，虽然这种方法很常用，但可参考的代码的实现比较少，下面对这种方法及其实现进行详细的阐述。 首先，利用DFS判断无向图中是否换的原理是：若在深度优先搜索的过程中遇到回边(即指向已经访问过的顶点的边)，则必定存在环。 所以说，是否存...
图综合练习--拓扑排序_图解：有向环、拓扑排序与Kosaraju算法
weixin_39633954的博客
11-29 521
图算法第三篇 图解：有向环、拓扑排序与Kosaraju算法 首先来看一下今天的内容大纲，内容非常多，主要是对算法思路与来源的讲解，图文并茂，希望对你有帮助~1.有向图的概念和表示 概念有向图与上一篇文章中的无向图相对，边是有方向的，每条边所连接的两个顶点都是一个有序对，它们的邻接性都是单向的。 一幅有方向的图（或有向图）是由一组顶点和一组有方向的边组成的，每条有方向的边都连接着一对有序的顶点。...
判断一个图是否有环
大西瓜不甜的博客
09-27 1412
对于无向图 算法1 我们知道对于环1-2-3-4-1，每个节点的度都是2，基于此我们有如下算法（这是类似于有向图的拓扑排序）： 求出图中所有顶点的度， 删除图中所有度<=1的顶点以及与该顶点相关的边，把与这些边相关的顶点的度减一 如果还有度<=1的顶点重复步骤2 最后如果还存在未被删除的顶点，则表示有环；否则没有环 时间复杂度为O（E+V），其中E、V分别为图中边和顶点的数目，这个算法我们稍后分析算法3的时候再分析。 算法2 深度优先遍历该图，如果在遍历的过程中，发现某个节.
【数据结构——有向图】有环无环判定、拓扑排序（DFS、BFS）
weixin_45618869的博客
09-04 7207
有向图（Directed Graph），也被称为有向图形或方向图，是一种图的类型。在有向图中，图中的边具有方向，从一个顶点指向另一个顶点。在有向图中，每个顶点表示一个实体，而有向边则表示实体之间的关系或连接。这种有方向性的边表明了连接的起点和终点之间的单向关系。因此，有向图中的边具有起点和终点的概念，它们不能逆转方向。与有向图对应的是无向图（Undirected Graph），在无向图中，边是没有方向的，可以双向移动。相比之下，有向图更适合描述具有明确方向性的关系，例如有向的路径、进程之间的依赖关系等。
判断图中是否有环的三种方法
热门推荐
CC
09-04 4万+
0 什么是环？ 在图论中，环（英语：cycle）是一条只有第一个和最后一个顶点重复的非空路径。 在有向图中，一个结点经过两种路线到达另一个结点，未必形成环。 1 拓扑排序 1.1 无向图 使用拓扑排序可以判断一个无向图中是否存在环，具体步骤如下： 求出图中所有结点的度。 将所有度 <= 1 的结点入队。（独立结点的度为 0） 当队列不空时，弹出队首元素，把与队首元素相邻节点的度减一。如果相邻节点的度变为一，则将相邻结点入队。 循环结束时判断已经访问的结点数是否等于 n。等于 n 说明全部结点都.
图的遍历，存储和求解实现
04-03
DFS可以用栈来辅助实现，常用于检测环路、拓扑排序等问题。 - **广度优先搜索（BFS）**：BFS使用队列来存储待访问的节点，先访问距离起始节点近的节点，然后逐渐扩大搜索范围。BFS常用于找到最短路径问题，例如在...
数据库系统l试题库及答案 第7章图.docx
04-01
5. 拓扑排序：拓扑排序是对有向无环图(DAG)的顶点进行排序，使得对于每条有向边(u, v)，u都在v之前。拓扑排序的结果可能有多个，但所有顶点按其编号的顺序出现在对角线以上表示没有环路。 6. 关键路径：关键路径是...
实验一Kruskal.doc
03-02
- `kruskal()`：Kruskal算法的主要实现，先对边进行排序，然后逐个检查并添加边，过程中使用`find()`和`unit()`进行环路检测。 - `traverse()`：遍历最小生成树，输出或显示已选择的边。 算法复杂度分析： Kruskal...
深度优先搜索matlab.docx
06-13
总结来说，这个MATLAB实现的深度优先搜索算法能够有效地处理有向和无向图，支持随机路径生成，且能检测图中的环路。它利用邻接矩阵作为数据结构，通过节点颜色的变化跟踪搜索过程，是图论和算法学习中的一个典型应用...
networkx_pdf
03-03
- **有向无环图算法** (Directed Acyclic Graphs)：针对 DAG 的特殊算法。 - **距离测量算法** (Distance Measures)：计算图中节点之间的距离。 - **距离规则图算法** (Distance-Regular Graphs)：处理距离规则图的...
图论基础之 图中找环
lj12358132134的博客
05-26 1万+
对于有向图而言 可以使用拓扑排序的方式找出图中的环#include&lt;bits/stdc++.h&gt; using namespace std; const int maxn = 1e5+7; int n; int du[maxn];//入度 vector&lt;int&gt; gra[10]; vector&lt;int&gt; res; void addedge(int a,int b)...
【算法修炼】图论算法一（图的表示、图的遍历、图中环的检测）
Mxeron的博客
02-21 1523
学习自：https://labuladong.gitee.io/algo/2/19/35/ 终于开始了数据结构算法的学习…（????数据结构） 一、图的基本结构 二、图的存储方式 图结构的两种存储方式： 无向图的邻接矩阵一定是对称的。 三、度 四、图的遍历 图和多叉树最大的区别是，图是可能包含环的，你从图的某一个节点开始遍历，有可能走了一圈又回到这个节点。 所以，如果图包含环，遍历框架就要一个 visited 数组进行辅助： // 记录被遍历过的节点 boolean[] visited; //
有向图的几个算法分析总结
点缀星辰
09-14 3245
简介     前面讨论的很多文章里，都是针对无向图进行的分析。无向图的一个特性就是其中一旦两个节点a和b是相连的，这就意味着有路径从a到b，同时也有从b到a的。它具体对应的矩阵表达方式对应着一个对称矩阵。而这里重点是考察有向图。和无向图比起来，有向图更加多了一种出入度的概念。因为方向的有向性，很多以前在无向图里看起来比较简单的问题在这里会变得更加有意思。   有向图定义 　　一个常用的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值