基于C++的带权无向图的实现 （六）- 关节点算法

已于 2022-05-05 21:01:57 修改
阅读量1.5k 收藏 12
点赞数 5
分类专栏： 数据结构和算法 文章标签： 数据结构 算法 c++
于 2021-02-14 21:44:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42375679/article/details/113808243
版权

该系列文章是本人整理的有关带权无向图的数据结构和算法的分析与实现，若要查看源码可以访问我的github仓库，如有问题或者建议欢迎各位指出。

目录

基于C++的带权无向图的实现 （一）- 数据结构
基于C++的带权无向图的实现 （二）- 遍历算法
基于C++的带权无向图的实现 （三）- Prim最小生成树算法
基于C++的带权无向图的实现 （四）- Dijkstra最短路径算法
基于C++的带权无向图的实现 （五）- 连通图和连通分量
基于C++的带权无向图的实现 （六）- 关节点算法

关节点（Articulation Points）

如果移除顶点和关联的边会使连通分量的数量增加，则将该顶点称为图中的割点，或叫关节点。 拿上节内容的图G来举例，如下所示：
在这里插入图片描述

由于图G为非连通图，具有两个连通分量，所有关节点即为每个连通分量的关节点之和。左边的连通分量的关节点为9，右边的连通分量的关节点为1，3，4。如果任意删除这四个顶点中的一个顶点及其相邻所有边，该图的连通分量数量将会增加。比如删除顶点9或者顶点4或顶点3的时候，图中的连通分量会变成三个；删除顶点1的时候，图中的连通分量会变成四个。


求关节点的算法

暴力求解

暴力求解理解起来非常简单。

  1. 记录图中原有的连通分量的数量N
  2. 遍历图G中的每一个顶点u：
    1. 删除顶点 u及其相邻的所有边。
    2. 计算删除顶点u及其相邻的所有边后连通分量 M。如果M > N，则说明顶点u是分割点。
    3. 将顶点u重新添加到图中。

这种方法的缺点就是时间复杂度非常高，由于要依次删除和还原每一个顶点，并且每次删除顶点后都要进行深度优先遍历，所以其时间复杂度为O(N ∗ (N+ M)) 。


Tarjan算法

这种算法也是当下求关节点的最优算法，时间复杂度为O(N + M)，对于每个连通分量，只需要进行一次深度优先遍历即可。在介绍这种算法之前，我们先了解几个概念：

  1. 树边(Tree edge): 指向未访问过的顶点的边，也叫父子边。
  2. 回边(Back edge)：指向已访问过的祖先顶点的边。
  3. 深度优先搜索树（DFS trees）
    深度优先搜索树是指在图中按照深度优先遍历顺序产生的树。对于图1，其深度优先生成树如下（蓝色实线表示树边，红色虚线表示回边，箭头指向的是可回溯到的祖先顶点）：

在这里插入图片描述


对于Tarjan算法，有两类顶点可以作为关节点：

  1. 对于根节点u，若在根节点下有两颗或两颗以上的子树，那么该根节点可视为关节点。上图中的两颗DFS搜索树的根节点分别为1和7，由于他们都只有一颗子树，所以在这个例子中这两个根节点都不为关节点。
  2. 当u不为根节点并且当u不为叶子结点时，如果u的子树均没有指向u的祖先顶点的回边，则说明删除u之后，图中的连通分量数量会增加，那么此时u为关节点/割点。对于上图中的顶点3，他只有一颗子树（顶点6），且基于顶点6的子树没有指向顶点3祖先的回边，所以顶点3是图中的关节点。

在Tarjan算法中中，需要使用两个数组dfn[u]和 low[u]，他们的用途分别为：

  1. dfn[u]：深度优先遍历的次序序号。
  2. low[u]：顶点u或其子树能回溯到的最早的祖先结点ID。

dfn[u]的记录非常容易，只需要从1开始，每遍历一个未访问过的顶点时加1即可。

对于low[u]的记录和更新，则需要通过以下几步：

  1. 每遍历到一个未访问过的顶点时，将其初始化为深度优先遍历的次序序号，即low[u] = dfn[u], 表示以u为根节点的子树能回溯到的最早的祖先是其自己。
  2. 对于u的邻居结点v：
    1. 如果(u,v)为树边，那么对于v能回溯到的最早的祖先，u肯定也能回溯到。此时：low[u] = min(low[u], low[v])
    2. 如果(u,v)为回边，即v已经访问过，但v不是u的父亲，那么此时基于顶点u的子树可以回溯到祖先v。此时low[u] = min(low[u], dfn[v])

如果(u,v)为树边，且low[v] >= dfn[u]时，即可判断u为关节点，这条公式的含义如下：

  1. 当low[v] > dfn[u]时，表示以v为根节点的子树能回溯到的最早的祖先为顶点v自己。如图2(b)中的顶点6相当于v，顶点3相当于u。由于顶点6没有任何回边（红色虚线）指向顶点6之前的顶点，所以可以判断顶点3为关节点。
  2. 当low[v] == dfn[u] 时，表示以v为根节点的子树只能回溯到顶点u为止，那么既然他只能回溯到顶点u，当你移除顶点u的时候，以v为根节点的子树不就凉了？所以此时顶点u即为关节点。

下面用一组图示和表格的方式来表示图2中各个顶点dfn和low记录的值：

在这里插入图片描述
在这里插入图片描述
当u = 1，v = 3时， low[v] = 4，dfn[u] = 2，low[v] > dfn[u]，所以顶点1为关节点。
当u = 3，v = 6时，low[v] = 5， dfn[u] = 4，low[v] > dfn[u]，所以顶点3为关节点。
当u = 4，v = 5时，low[v] = 7， dfn[u] = 6，low[v] > dfn[u]，所以顶点4为关节点。
当u = 9，v = 10时，low[v] = 10， dfn[u] = 10，low[v] == dfn[u]，所以顶点9为关节点。


代码实现

在Graph类中除了上节内容实现的功能外，额外添加了求关节点的算法，T为提前定义好的模板：


函数名用途
vector articulation_points(int choice)求关节点的函数
void violent_solution(vector& articulation_point_collection)暴力求解法
void dft(T u, T root, T parent, set& visited_vertices, int& dfn_cnt, map<T, int>& dfn, map<T, int>& low, vector& articulation_point_collection)Tarjan算法

  1. 边的定义(edge.hpp):
template <typename T>
class Edge {
public:
	T vertex;
	int weight;

	Edge(T neighbour_vertex) {
		this->vertex = neighbour_vertex;
		this->weight = 0;
	}

	Edge(T neighbour_vertex, int weight) {
		this->vertex = neighbour_vertex;
		this->weight = weight;
	}

	bool operator<(const Edge& obj) const {
		return obj.vertex > vertex;
	}

	bool operator==(const Edge& obj) const {
		return obj.vertex == vertex;
	}
};
  1. 图的定义(graph.hpp)
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<limits.h>
#include "edge.hpp"
using namespace std;

template <typename T>
class Graph {
public:
	map<T, set<Edge<T>>> adj;  /* 邻接表 */

	bool contains(const T& u); /* 判断顶点u是否在图中 */
	bool adjacent(const T& u, const T& v); /* 判断顶点u和v是否相邻 */

	void add_vertex(const T& u); /* 添加顶点 */
	void add_edge(const T& u, const T& v, int weight); /* 添加边和权重 */

	void change_weight(const T& u, const T& v, int weight); /* 修改权重 */

	void remove_weight(const T& u, const T& v); /* 移除权重 */
	void remove_vertex(const T& u); /* 移除顶点 */
	void remove_edge(const T& u, const T& v); /* 移除边 */

	int degree(const T& u); /* 求顶点的度数 */
	int num_vertices(); /* 求图中顶点的总数 */
	int num_edges(); /* 求图中边的总数*/
	int largest_degree(); /* 求图中的最大度数 */

	int get_weight(const T& u, const T& v); /* 得到某两个顶点之间边的权重 */
	vector<T> get_vertices(); /* 得到图中所有顶点 */
	map<T, int> get_neighbours(const T& u); /* 得到顶点u的所有边 */

	void show();

	void dft_recursion(const T& u, set<T>& visited, vector<T>& result); /* 深度优先遍历递归辅助函数 */
	vector<T> depth_first_rec(const T& u); /* 深度优先遍历递归法 */
	vector<T> depth_first_itr(const T& u); /* 深度优先遍历迭代法*/
	vector<T> breadth_first(const T& u); /* 广度优先遍历迭代法 */

	Graph<T> prim(T v); /* prim最小生成树算法 */

	map<T, int> dijkstra(T start); /*  dijkstra最短路径算法 */

	vector<vector<T>>  get_connected_components(); /* 获得图中的连通分量 */
	void  print_connected_components(const vector<vector<T>>& connected_components); /* 打印连通分量 */

	vector<T> articulation_points(int choice); /* 获得图中的关节点（分割点）*/

private:
	void dft(T u, T root, T parent, set<T>& visited_vertices, /* 获得关节点的Tarjan算法 */
		int& dfn_cnt, map<T, int>& dfn, map<T, int>& low, vector<T>& articulation_point_collection);
	void violent_solution(vector<T>& articulation_point_collection); /* 获得关节点的暴力求解法 */
};

函数实现代码：

template <typename T> vector<T> Graph<T>::articulation_points(int choice)
{
	// 计算深度优先遍历的次数
	int dfn_cnt = 0;

	// 记录图中出现的分割点
	vector<T> articulation_point_collection;

	// 记录深度优先遍历顺序
	map<T, int> dfn;

	// 记录以某个特定顶点为根的子树能回溯到的最早的祖先顶点
	map<T, int> low;

	// 记录已访问过的顶点
	set<T> visited_vertices;

	if (choice == 1) {
		violent_solution(articulation_point_collection);
	}

	else if (choice == 2) {
		// 对未访问过的顶点进行深度优先遍历求分割点（实际上是在每一个连通分量中使用一次深度优先遍历）
		for (auto u : adj) {
			if (visited_vertices.find(u.first) == visited_vertices.end())
				dft(u.first, u.first, u.first, visited_vertices, dfn_cnt, dfn, low, articulation_point_collection);
		}
		int a = 1;
	}
	
	return articulation_point_collection;
}

template <typename T> void Graph<T>::violent_solution(vector<T>& articulation_point_collection)
{
	// 获得原来的图的连通分量数量
	unsigned original_number = get_connected_components().size();

	// 获得图中的所有顶点
	vector<T>vertices = get_vertices();

	for (T vertex : vertices) {
		// 暂存要删除的顶点附近的邻居
		map<T, int> temp_neighbours = get_neighbours(vertex);
		// 删除顶点
		remove_vertex(vertex);

		// 将删除后的连通分量数量与删除前的比较
		unsigned current_number = get_connected_components().size();
		if (current_number > original_number) articulation_point_collection.push_back(vertex);

		// 添加回顶点及对应的边
		add_vertex(vertex);
		for (auto neighbour : temp_neighbours) {
			add_edge(vertex, neighbour.first, neighbour.second);
		}
	}
	
}

template <typename T> void Graph<T>::dft(T u, T root, T parent, set<T>& visited_vertices,
	int& dfn_cnt, map<T, int>& dfn, map<T, int>& low, vector<T>& articulation_point_collection)
{
	// 记录深度优先遍历次序
	dfn_cnt++;
	dfn[u] = dfn_cnt;

	// 初始化low[u]
	low[u] = dfn[u];

	// 标记当前顶点为已访问
	visited_vertices.insert(u);

	// 记录子树数量
	int n_subtree= 0;

	// 记录该顶点是否为关节点
	bool is_cut = false;

	for (auto edge : adj[u]) {
		T v = edge.vertex;

		// 当(u,v)边为树边时
		if (visited_vertices.find(v) == visited_vertices.end()) {
			n_subtree++;

			// 对u的孩子v进行深度优先遍历，此时u作为parent
			dft(v, root, u, visited_vertices, dfn_cnt, dfn, low, articulation_point_collection);

			// 以v为根节点的子树能访问到的祖先必然也能从u结点出发访问到，依此来更新u值
			low[u] = min(low[u], low[v]);

			// 以v为根节点的子树能访问到的最早的祖先为u或者v时，则可判断出顶点u（非根节点）为关节点
			if (u != root && low[v] >= dfn[u]) is_cut = true;
		}

		// 当(u,v)边为回边时
		// 使用v的深度优先遍历次序来更新low[u]
		else if (v != parent) low[u] = min(low[u], dfn[v]);
	}

	// u为根节点且子树数量大于等于2的情况
	if (n_subtree >= 2 && u == root) is_cut = true;

	// 记录关节点
	if (is_cut) articulation_point_collection.push_back(u);

}

测试

测试案例（graph_testing.cpp）：

void test06(Graph<int> g) {
    cout << "暴力求解得到的分割点为：";
    auto articulation_points2 = g.articulation_points(1);
    for (auto u : articulation_points2) cout << " " << u;
    cout << endl;

    cout << "Targan算法求得的分割点为：";
    auto articulation_points1 = g.articulation_points(2);
    for (auto u : articulation_points1) cout << " " << u;
    cout << endl;

}

int main()
{
    //Graph<char> g;
    //g.add_vertex('A');
    //g.add_vertex('B');
    //g.add_vertex('C');
    //g.add_vertex('D');
    //g.add_vertex('E');
    //g.add_vertex('F');
    //g.add_vertex('G');

    //g.add_edge('A', 'B', 7);
    //g.add_edge('A', 'D', 5);
    //g.add_edge('B', 'C', 8);
    //g.add_edge('B', 'D', 9);
    //g.add_edge('B', 'E', 7);
    //g.add_edge('C', 'E', 5);
    //g.add_edge('D', 'E', 15);
    //g.add_edge('D', 'F', 6);
    //g.add_edge('E', 'F', 8);
    //g.add_edge('E', 'G', 9);
    //g.add_edge('F', 'G', 11);

    //g.add_vertex('H');
    //g.add_edge('B', 'H', 9);
    //g.add_edge('A', 'H', 10);
    //g.add_edge('D', 'H', 11);
    //g.add_edge('A', 'H', 12);
    //g.remove_vertex('H');
    //cout << "打印图中顶点及其邻接表的详细信息如下" << endl;
    //g.show();
    //cout << endl;
    
    // test01(g);
    // test02(g);
    // test03(g);
    // test04(g);
  
    Graph<int> g;

    g.add_vertex(0);
    g.add_vertex(1);
    g.add_vertex(2);
    g.add_vertex(3);
    g.add_vertex(4);
    g.add_vertex(5);
    g.add_vertex(6);
    g.add_vertex(7);
    g.add_vertex(8);
    g.add_vertex(9);
    g.add_vertex(10);
    g.add_vertex(11);
    g.add_vertex(12);

    g.add_edge(0, 1 , 1);
    g.add_edge(0, 2, 1);
    g.add_edge(1, 2, 1);
    g.add_edge(1, 3, 1);
    g.add_edge(1, 4, 1);
    g.add_edge(3, 6, 1);
    g.add_edge(4, 5, 1);
    g.add_edge(7, 8, 1);
    g.add_edge(7, 9, 1);
    g.add_edge(7, 12, 1);
    g.add_edge(8, 9, 1);
    g.add_edge(8, 12, 1);
    g.add_edge(9, 10, 1);
    g.add_edge(9, 11, 1);
    g.add_edge(9, 12, 1);
    g.add_edge(10, 11, 1);
    cout << "打印图中顶点及其邻接表的详细信息如下" << endl;
    g.show();
    cout << endl;

    test06(g);
    return 0;
}

运行结果：
在这里插入图片描述

-盛航
关注
  • 5
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
算法 : 关节点问题（邻接表，图的遍历）
MrxiaoAXiao的博客
03-25 1200
策略：图的遍历，双连通分量方法：深度优先生成树（DFS），然后判断是否是关节点。关节点定义：无向图G=（V,E）中，可能存在某个(多个)结点a，删除a后，图G就不再是连通图，则a就是图G的关节点。应用场景：例如：通讯网络中的关键结点（如果断开就没办法连接，通讯网络就中断了）如图：通信网络中的结点1就是关节点，删除1后图：整体代码如下：int adjvex;}ENode;//根节点的孩子数int t=0;//时间戳int sum=0;//总个数//parents数组。
基于C++的带权无向图的实现 （一）- 数据结构
weixin_42375679的博客
01-11 8733
基于C++的带权重的无向图的实现（邻接表法）
无向图的深度优先生成树和广度优先生成树
weixin_34306676的博客
11-03 1036
#include <stdio.h> #include <malloc.h> #define MAXV 100//最大顶点个数 int visited[MAXV];//全局数组 typedef int InfoType; typedef struct { int edges[MAXV][MAXV]...
Algorithm第四版算法 C++实现(十八)——加权无向图的构造及kruskal算法（求最小生成树）
Charlesix59的博客
08-14 316
带权边的构造 /*带权图的边*/ class edge { private: int v; int w; double wei; public: edge(int v, int w, double weight) { this->v = v; this->w = w; this->wei = weight; } double weight() { return wei; } int either() { return v; } int othe
GeminiGraph：Graph.hpp中Graph类的init()函数详解
Reyon_的博客
12-15 660
void init() { edge_data_size = std::is_same<EdgeData, Empty>::value ? 0 : sizeof(EdgeData); unit_size = sizeof(VertexId) + edge_data_size; edge_unit_size = sizeof(VertexId) + unit_size; assert( numa_available() != -1 ); asse...
迪杰斯特拉算法(Dijkstra)算法
weixin_36670529的博客
06-17 2791
迪杰斯特拉(Dijkstra)算法是典型最短路径算法，用于计算一个节点到其他节点的最短路径。它的主要特点是以起始点为中心向外层层扩展(广度优先搜索思想)，直到扩展到终点为止。 大概就是这样一个有权图，Dijkstra算法可以计算任意节点到其他节点的最短路径： 算法思路 指定一个节点，例如我们要.........
C++基于 Retinex 的图像增强算法-Opencv-C++.zip
05-09
C++基于 Retinex 的图像增强算法-Opencv-C++。 一种常见图像增强算法，基于Retinex理论。本代码通过vs2015编译通过，Opencv3.1.0，C++ opencv c++ Retinex 图像增强
基于C++语言实现非局部均值图像去噪算法源码.zip
05-31
基于C++语言实现非局部均值图像去噪算法源码。基于C++语言实现非局部均值图像去噪算法。 并进行高噪声图像降噪。基于C++语言实现非局部均值图像去噪算法源码。基于C++语言实现非局部均值图像去噪算法。 并进行高噪声...
基于C++、Qt实现底层绘图算法的绘图系统.zip
10-21
基于C++、Qt实现底层绘图算法的绘图系统 基于C++、Qt实现底层绘图算法的绘图系统 基于C++、Qt实现底层绘图算法的绘图系统 基于C++、Qt实现底层绘图算法的绘图系统 基于C++、Qt实现底层绘图算法的绘图系统 基于C++、...
C++实现oj算法代码-贪心算法.zip
最新发布
10-28
C++实现oj算法代码---贪心算法
C语言寻找无向图两点间的最短路径
08-26
主要为大家详细介绍了C语言寻找无向图两点间的最短路径，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
连通图tarjan算法动画讲解呕心沥血之作
02-01
tarjan算法呕心沥血之作，动画演示，步步清晰可见，详细的描述了tarjan算法的工作过程，比网上的单纯的图片更加容易理解。
数据结构-基本算法-无向图存储转换
05-21
数据结构-基本算法-无向图存储转换(学生时代源码，调试可运行)
【一】图算法之Dijkstra算法及C++实现
Allen_Duke的博客
04-13 2920
0. 前言 由于之前一个比赛用到了路径规划，于是就学习了一些图论中路径规划的算法，所以将自己的学习后的代码记录下来以作备忘。但也是只学了图搜索这类的方法，基于采样的RRT等其他方法个人认为不适合我的应用场景，所以也没有了解。 1. Dijkstra算法 单源最短路径问题：给定一个图G=(V，E)G=(V，E)G=(V，E)，求源结点s∈Vs∈Vs∈V到图中每个结点v∈Vv∈Vv∈V的最短路径。 Dijkstra算法就适用于解决带权重的有向图（或无向图）上的单源最短路径问题，同时算法要求图中所有边的权重非负。
数据结构与算法——最短路径Dijkstra算法的C++实现
热门推荐
Be The Best！
05-04 1万+
数据结构与算法——最短路径Dijkstra算法的C++实现
Dijkstra算法实现C++
君莫笑
09-28 404
先占个坑：开启算法笔记 迪杰斯特拉(Dijkstra)算法是典型的最短路径算法，计算一个节点到其他节点的最短路径。 它的主要特点是以起始点为中心向外层扩展(广度优先搜索思想)，直到扩展到终点为止。 ...
C++ 最短路径之Dijkstra算法
struct_GS的博客
09-08 1706
迪杰斯特拉算法(Dijkstra)是由荷兰计算机科学家狄克斯特拉于1959年提出的，因此又叫狄克斯特拉算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有权图中最短路径问题。迪杰斯特拉算法主要特点是从起始点开始，采用贪心策略，每次遍历到始点距离最近且未访问过的顶点的邻接节点，直到扩展到终点为止。 Dijkstra算法 只能用于计算单源最短路，而且无法处理负权边。 时间复杂度：O() 【代码实现】 //假设有n个点，m条边，求1~n...
Tarjan算法：求解无向连通图图的割点（关节点）与桥（割边）
weixin_30246221的博客
07-16 1416
1. 割点与连通度 在无向连通图中，删除一个顶点v及其相连的边后，原图从一个连通分量变成了两个或多个连通分量，则称顶点v为割点，同时也称关节点(Articulation Point)。一个没有关节点的连通图称为重连通图(biconnected graph)。若在连通图上至少删去k 个顶点才能破坏图的连通性，则称此图的连通度为k。 关节点和重连通图在实际中较多应用。显然，一个表示通信网络的图...
图的关节点算法实现
qq_25744595的博客
11-27 5102
关节点：可以将一个连通分量分割成两个或多个连通分量的点。 重连通图：没有关节点的图，在重连通图中任意两点之间至少存在两条路径 关节点求法：算法较难理解，算法结合了先序深度搜索和后序深度搜索，先序深度搜索确定每个点访问的顺序，而后序深度搜索则根据先序计算的顺序确定关节点。具体递归算法步骤： 递归算法： 递归算法中，第一部分为记录结点访问次序，中间部分为调用递归函数访问子节点，第三部分为根据递归函数的...
请用c++实现无向图网状结构的链路查询算法
03-31
不过，我可以向您提供一些思路和代码片段，帮助您实现无向图网状结构的链路查询算法。 首先，我们需要定义一个图的结构体，包括顶点数、边数、邻接矩阵等： ```c #define MAX_VERTEX_NUM 100 // 最大顶点数 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

-盛航

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值