寻找无向图的关节点(Articulation Points)和判断图是否是双连通图(Biconnect Graph)

最新推荐文章于 2024-07-01 10:25:42 发布
最新推荐文章于 2024-07-01 10:25:42 发布
阅读量7.9k 收藏 62
点赞数 17
分类专栏： c++ 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40691051/article/details/103092444
版权
图论 同时被 2 个专栏收录
22 篇文章 0 订阅
订阅专栏
c++
17 篇文章 0 订阅
订阅专栏

一、定义：

关节点(Articulation Poinst)是指，在原本连通的图，在删除关节点及依附的边之后，图将被分割成至少两个连通分量(原本整连通的图变得不连通)。
另外,没有一个关节点的连通图称为双连通图(Biconnect Graph)

二、求解关节点算法：

首先，将无向连通图从某个顶点开始进行DFS遍历，遍历会得到一个DFS树(深度优先生成树)
相信读者已经通过其他地方知道了下面的判断顶点u是否是关节点的原则:

1、如果u是整颗DFS树的根，如果u至少有两个子女,那么u必然是关节点。

2、DFS树中叶节点不是关节点

3、非根顶点u(不整颗DFS树的根)不是关节点的充要条件是：它的任一子孙都可以沿某条路径绕过顶点u达到u的任一祖先w (w!=u),u不属于该路径(这条路径包括回边)
ps:（回边是原本图中有的,在DFS数里没有的)

针对判定原则里的1我们再定义一个变量children用于记录当前顶点的子女数，如果当前顶点是根结点(整棵树的根)，再定一个数组parent,parent[u]表示u的双亲是谁。

针对判定原则里的2,3我们再定义：
1、depth[u]为顶点u在DFS树中的深度
2、low[u]为顶点u的所有子孙(包括u)能够到达的邻居中的最低(小)深度。

显然，在DFS树中如果顶点w是顶点u的祖先,那么必有depth[w] < depth[u]。
因此，在DFS的时候，先让depth[u]等于low[u]等于当前节点的深度，然后再看节点u的子孙里有没有那个子孙v有到u的某个祖先w的回边，有的话更新那个子孙v以及其那个子孙v所有祖先的low[]的值为depth[w](直到那个祖先w)
然后就可以判断了，假设u是v的双亲，如果low[u]>=depth[u]那么u的子孙都没一条边(回边)可以绕过u到达u的祖先，所以u是个关节点。

维基百科上有个动画：(这个动画有点小问题，右边：D2回溯到D1那就可以判断D1为关节点了,还有D4回溯到D2那里没画，当然这是小问题；左边：D3回溯到D2哪里标绿线才对，标错了)
在这里插入图片描述
想要它慢点，暂停？用windows media player打开就好。

看下维基上的伪代码:

GetArticulationPoints(i, d)
    visited[i] = true
    depth[i] = d
    low[i] = d
    childCount = 0
    isArticulation = false
    for each ni in adj[i]
        if not visited[ni]
            parent[ni] = i
            GetArticulationPoints(ni, d + 1)
            childCount = childCount + 1
            if low[ni] >= depth[i]
                isArticulation = true
            low[i] = Min(low[i], low[ni])
        else if ni != parent[i]
            low[i] = Min(low[i], depth[ni])
    if (parent[i] != null and isArticulation) or (parent[i] == null and childCount > 1)
        Output i as articulation point

C++代码：

#include<iostream>
#include<list> 
#include<algorithm>  //for min
#define NIL -1

using namespace std;
class Graph
{
	int n;		//图中节点个数
	list<int>* adj;   //邻接表
	void APUtil(int v,bool visited[],int depth[],int low[],
			int parent[],int curDepth,bool AP[]); 
public:
	Graph(int _n);
	void addEdge(int v,int w);
	void AP();			//求出连通图中的关节点 
};

Graph::Graph(int _n)
{
	n = _n;
	adj = new list<int>[_n];
}

void Graph::addEdge(int v,int w)
{
	adj[v].push_back(w);
	adj[w].push_back(v);
}

void Graph::APUtil(int u,bool visited[],int depth[],int low[],
			int parent[],int curDepth,bool AP[]) 
{
	visited[u] = true;				//已访问 
	int children = 0;				//孩子数 
	
	// 初始化u的深度和能到达的深度最小的祖先 
	depth[u] = low[u] = curDepth;	
	
	list<int>::iterator it;
	for( it = adj[u].begin(); it != adj[u].end(); it++)
	{
		int v = *it;
		
		if( !visited[v])		//v没被访问过
		{
			parent[v] = u;		//设置v的双亲 
			children++;			//u的子女+1
			APUtil(v, visited, depth, low, parent, curDepth + 1, AP); 
			
			//访问完v后回溯到这里,检查下u的子孙里有没有那个能
			//有绕过u能到达的深度最小的祖先,有的话u从子孙那边 
			//到那个祖先 ，更新low[u] 
			low[u] = min(low[u], low[v]); 
			
			//判断:
			//1、如果u是根结点(整颗生成树的根,其双亲为-1，即NIL) 
			//如果children >  1,则u是关节点
			if( parent[u] == NIL && children > 1)
			{
				AP[u] = true; 
			} 
			
			//2、不是根结点，但是有子女v无法绕过它u到它u的祖先w
			//u是关节点,此时low[v] >= depth[u] 
			if( parent[u] != NIL && low[v] >= depth[u]) 
			{
				AP[u] = true;
			}
		}
		else if( v != parent[u])			 
		{//v访问过了，说明v是当前节点u的祖先,v找到了一条边(回边到v的祖先),
		//这里排除下v是u的双亲(因为v是u的双亲的话处理的就不是回边了，这条边在DFS树)
			low[u] = min(low[u], depth[v]);			//更新low[u]; 
		} 
	} 
}

void Graph::AP()
{
	bool *visited = new bool[n];
	int *parent = new int[n];
	int *low = new int[n];
	int *depth = new int[n];
	bool *AP = new bool[n];
	
	for(int i = 0; i < n; i++)
	{
		AP[i] = false;
		parent[i] = NIL;
		visited[i] = false;
	} 
	for(int i = 0; i < n; i++)
	{
		if(!visited[i])
		{
			APUtil(i,visited,depth,low,parent,0,AP);
		}
	}
	
	for(int i = 0; i < n; i++)
	{
		if(AP[i] == true)
		{
			cout<<i<<"  ";
		}
	}
	cout<<endl;
}

以动画里图为例测试：

int main()
{
	cout<<"输入图的关节点有:"<<endl;
	Graph g1(15);
	g1.addEdge(0,1);
	g1.addEdge(1,2);
	g1.addEdge(1,6);
	g1.addEdge(2,3);
	g1.addEdge(2,4);
	g1.addEdge(3,4);
	g1.addEdge(4,5);
	g1.addEdge(5,6);
	g1.addEdge(6,7);
	g1.addEdge(1,8);
	g1.addEdge(0,9);
	g1.addEdge(9,10);
	g1.addEdge(10,11);
	g1.addEdge(10,13);
	g1.addEdge(11,12);
	g1.addEdge(12,13);
	g1.AP();
	return 0; 
}

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

还有一种写法：
不用深度depth[]，用disc[u]最早发现的时间的来记录当前顶点u在DFS树在被发现的次序,而low[u]来表示顶点u到达的disc值最小的祖先(不是双亲)。

void Graph::APUtil(int u,bool visited[],int disc[],int low[],
			int parent[],int &time,bool AP[]) 
{
	visited[u] = true;				//已访问 
	int children = 0;				//孩子数 
	
	// 初始化u的深度和能到达的深度最小的祖先 
	disc[u] = low[u] = ++time;	
	
	list<int>::iterator it;
	for( it = adj[u].begin(); it != adj[u].end(); it++)
	{
		int v = *it;
		
		if( !visited[v])		//v没被访问过
		{
			parent[v] = u;		//设置v的双亲 
			children++;			//u的子女+1
			APUtil(v, visited, disc, low, parent, time, AP); 
			
			//访问完v后回溯到这里,检查下u的子孙里有没有那个能
			//有绕过u能到达的深度最小的祖先,有的话u从子孙那边 
			//到那个祖先 ，更新low[u] 
			low[u] = min(low[u], low[v]); 
			
			//判断:
			//1、如果u是根结点(整颗生成树的根,其双亲为-1，即NIL) 
			//如果children >  1,则u是关节点
			if( parent[u] == NIL && children > 1)
			{
				AP[u] = true; 
			} 
			
			//2、不是根结点，但是有子女v无法绕过它u到它u的祖先w
			//u是关节点,此时low[v] >= disc[u] 
			if( parent[u] != NIL && low[v] >= disc[u]) 
			{
				AP[u] = true;
			}
		}
		else if( v != parent[u])			 
		{//v访问过了，说明v是当前节点u的祖先,v找到了一条边(回边到v的祖先),
		//这里排除下v是u的双亲(因为v是u的双亲的话处理的就不是回边了，这条边在DFS树)
			low[u] = min(low[u], disc[v]);			//更新low[u]; 
		} 
	} 
}
void Graph::AP()
{
	bool *visited = new bool[n];
	int *parent = new int[n];
	int *low = new int[n];
	int *disc = new int[n];
	bool *AP = new bool[n];
	
	for(int i = 0; i < n; i++)
	{
		AP[i] = false;
		parent[i] = NIL;
		visited[i] = false;
	} 
	
	int time = 0;
	for(int i = 0; i < n; i++)
	{
		if(!visited[i])
		{
			APUtil(i,visited,disc,low,parent,time,AP);
		}
	}
	
	for(int i = 0; i < n; i++)
	{
		if(AP[i] == true)
		{
			cout<<i<<"  ";
		}
	}
	cout<<endl;
}

三、判断是否是双连通图(Biconnect)

用上面的求关节点算法，求完有关节点必然不是双连通图,但是如果单纯地只想判断下是不是双连通图，只要找第一个关节点就知道，如果没有，还得看是不是连通图。

bool Graph::isBCUtil(int u,bool visited[],int depth[],int low[],
			int parent[],int curDepth) 
{
	visited[u] = true;				//已访问 
	int children = 0;				//孩子数 
	
	// 初始化u的深度和能到达的深度最小的祖先 
	depth[u] = low[u] = curDepth;	
	
	list<int>::iterator it;
	for( it = adj[u].begin(); it != adj[u].end(); it++)
	{
		int v = *it;
		
		if( !visited[v])		//v没被访问过
		{
			parent[v] = u;		//设置v的双亲 
			children++;			//u的子女+1
		
			if( isBCUtil(v, visited, depth, low, parent, curDepth + 1) == true) 
			{
				return true;
			}
			//访问完v后回溯到这里,检查下u的子孙里有没有那个能
			//有绕过u能到达的深度最小的祖先,有的话u从子孙那边 
			//到那个祖先 ，更新low[u] 
			low[u] = min(low[u], low[v]); 
			
			//判断:
			//1、如果u是根结点(整颗生成树的根,其双亲为-1，即NIL) 
			//如果children >  1,则u是关节点
			if( parent[u] == NIL && children > 1)
			{
				return true;
			} 
			
			//2、不是根结点，但是有子女v无法绕过它u到它u的祖先w
			//u是关节点,此时low[v] >= depth[u] 
			if( parent[u] != NIL && low[v] >= depth[u]) 
			{
				return true;
			}
		}
		else if( v != parent[u])			 
		{//v访问过了，说明v是当前节点u的祖先,v找到了一条边(回边到v的祖先),
		//这里排除下v是u的双亲(因为v是u的双亲的话处理的就不是回边了，这条边在DFS树)
			low[u] = min(low[u], depth[v]);			//更新low[u]; 
		} 
	} 
	return false;
}

bool Graph::isBC()
{
	bool *visited = new bool[n];
	int *parent = new int[n];
	int *low = new int[n];
	int *depth = new int[n];
	
	for(int i = 0; i < n; i++)
	{
		parent[i] = NIL;
		visited[i] = false;
	} 
	
	//isBCUtil返回图中有没有关节点 
	if( isBCUtil(0,visited,depth,low,parent,0) == true)
	{
		return false;
	} 
	
	for(int i = 0; i < n; i++ )
	{
		if(visited[i] == false)
		{//DFS后还有节点没被访问过，连通图都不是 
			return false;
		}
	}
	return true;
}

============================================================================================================================================================================================================================================================================

全部代码：
#include<iostream>
#include<list> 
#include<algorithm>  //for min
#define NIL -1

using namespace std;
class Graph
{
	int n;		//图中节点个数
	list<int>* adj;   //邻接表
	void APUtil(int v, bool visited[], int depth[], int low[],
			int parent[], int curDepth, bool AP[]); 
	bool isBCUtil(int v, bool visited[], int depth[], int low[],
			int parent[], int curDepth);
public:
	Graph(int _n);
	void addEdge(int v,int w);
	void AP();			//求出连通图中的关节点 
	bool isBC(); 
};

Graph::Graph(int _n)
{
	n = _n;
	adj = new list<int>[_n];
}
void Graph::addEdge(int v,int w)
{
	adj[v].push_back(w);
	adj[w].push_back(v);
}
void Graph::APUtil(int u,bool visited[],int depth[],int low[],
			int parent[],int curDepth,bool AP[]) 
{
	visited[u] = true;				//已访问 
	int children = 0;				//孩子数 
	
	// 初始化u的深度和能到达的深度最小的祖先 
	depth[u] = low[u] = curDepth;	
	
	list<int>::iterator it;
	for( it = adj[u].begin(); it != adj[u].end(); it++)
	{
		int v = *it;
		
		if( !visited[v])		//v没被访问过
		{
			parent[v] = u;		//设置v的双亲 
			children++;			//u的子女+1
			APUtil(v, visited, depth, low, parent, curDepth + 1, AP); 
			
			//访问完v后回溯到这里,检查下u的子孙里有没有那个能
			//有绕过u能到达的深度最小的祖先,有的话u从子孙那边 
			//到那个祖先 ，更新low[u] 
			low[u] = min(low[u], low[v]); 
			
			//判断:
			//1、如果u是根结点(整颗生成树的根,其双亲为-1，即NIL) 
			//如果children >  1,则u是关节点
			if( parent[u] == NIL && children > 1)
			{
				AP[u] = true; 
			} 
			
			//2、不是根结点，但是有子女v无法绕过它u到它u的祖先w
			//u是关节点,此时low[v] >= depth[u] 
			if( parent[u] != NIL && low[v] >= depth[u]) 
			{
				AP[u] = true;
			}
		}
		else if( v != parent[u])			 
		{//v访问过了，说明v是当前节点u的祖先,v找到了一条边(回边到v的祖先),
		//这里排除下v是u的双亲(因为v是u的双亲的话处理的就不是回边了，这条边在DFS树)
			low[u] = min(low[u], depth[v]);			//更新low[u]; 
		} 
	} 
}
void Graph::AP()
{
	bool *visited = new bool[n];
	int *parent = new int[n];
	int *low = new int[n];
	int *depth = new int[n];
	bool *AP = new bool[n];
	
	for(int i = 0; i < n; i++)
	{
		AP[i] = false;
		parent[i] = NIL;
		visited[i] = false;
	} 
	for(int i = 0; i < n; i++)
	{
		if(!visited[i])
		{
			APUtil(i,visited,depth,low,parent,0,AP);
		}
	}
	
	for(int i = 0; i < n; i++)
	{
		if(AP[i] == true)
		{
			cout<<i<<"  ";
		}
	}
	cout<<endl;
} 
bool Graph::isBCUtil(int u,bool visited[],int depth[],int low[],
			int parent[],int curDepth) 
{
	visited[u] = true;				//已访问 
	int children = 0;				//孩子数 
	
	// 初始化u的深度和能到达的深度最小的祖先 
	depth[u] = low[u] = curDepth;	
	
	list<int>::iterator it;
	for( it = adj[u].begin(); it != adj[u].end(); it++)
	{
		int v = *it;
		
		if( !visited[v])		//v没被访问过
		{
			parent[v] = u;		//设置v的双亲 
			children++;			//u的子女+1
		
			if( isBCUtil(v, visited, depth, low, parent, curDepth + 1) == true) 
			{
				return true;
			}
			//访问完v后回溯到这里,检查下u的子孙里有没有那个能
			//有绕过u能到达的深度最小的祖先,有的话u从子孙那边 
			//到那个祖先 ，更新low[u] 
			low[u] = min(low[u], low[v]); 
			
			//判断:
			//1、如果u是根结点(整颗生成树的根,其双亲为-1，即NIL) 
			//如果children >  1,则u是关节点
			if( parent[u] == NIL && children > 1)
			{
				return true;
			} 
			
			//2、不是根结点，但是有子女v无法绕过它u到它u的祖先w
			//u是关节点,此时low[v] >= depth[u] 
			if( parent[u] != NIL && low[v] >= depth[u]) 
			{
				return true;
			}
		}
		else if( v != parent[u])			 
		{//v访问过了，说明v是当前节点u的祖先,v找到了一条边(回边到v的祖先),
		//这里排除下v是u的双亲(因为v是u的双亲的话处理的就不是回边了，这条边在DFS树)
			low[u] = min(low[u], depth[v]);			//更新low[u]; 
		} 
	} 
	return false;
}
bool Graph::isBC()
{
	bool *visited = new bool[n];
	int *parent = new int[n];
	int *low = new int[n];
	int *depth = new int[n];
	
	for(int i = 0; i < n; i++)
	{
		parent[i] = NIL;
		visited[i] = false;
	} 
	
	//isBCUtil返回图中有没有关节点 
	if( isBCUtil(0,visited,depth,low,parent,0) == true)
	{
		return false;
	} 
	
	for(int i = 0; i < n; i++ )
	{
		if(visited[i] == false)
		{//DFS后还有节点没被访问过，连通图都不是 
			return false;
		}
	}
	return true;
} 
int main()
{
	cout<<"输入图的关节点有:"<<endl;
	Graph g1(15);
	g1.addEdge(0,1);
	g1.addEdge(1,2);
	g1.addEdge(1,6);
	g1.addEdge(2,3);
	g1.addEdge(2,4);
	g1.addEdge(3,4);
	g1.addEdge(4,5);
	g1.addEdge(5,6);
	g1.addEdge(6,7);
	g1.addEdge(1,8);
	g1.addEdge(0,9);
	g1.addEdge(9,10);
	g1.addEdge(10,11);
	g1.addEdge(10,13);
	g1.addEdge(11,12);
	g1.addEdge(12,13);
	g1.AP();
	cout<<"g1是不是双连通图:"<<endl;
	cout<<(g1.isBC() ? "是":"不是")<<endl;
	
	cout<<"g2是不是双连通图:"<<endl; 
	Graph g2(2);
	g2.addEdge(0,1);
	cout<<(g2.isBC() ? "是":"不是")<<endl; 
	
	cout<<"g3是不是双连通图:"<<endl; 
	Graph g3(4);
	g3.addEdge(0,1);
	g3.addEdge(1,2);
	g3.addEdge(1,3); 
	cout<<(g3.isBC() ? "是":"不是")<<endl; 
	
	cout<<"g4是不是双连通图:"<<endl;
	Graph g4(5); 
    g4.addEdge(1, 0); 
    g4.addEdge(0, 2); 
    g4.addEdge(2, 1); 
    g4.addEdge(0, 3); 
    g4.addEdge(3, 4); 
    cout<<(g4.isBC() ? "是":"不是")<<endl; 
  
  	cout<<"g5是不是双连通图:"<<endl;
    Graph g5(3); 
    g5.addEdge(0, 1); 
    g5.addEdge(1, 2); 
    g5.addEdge(2, 0); 
    cout<<(g5.isBC() ? "是":"不是")<<endl; 
	return 0; 
}

在这里插入图片描述

KRYON!
关注
  • 17
    点赞
  • 踩
  • 62
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Python 计算两个连通子图距离_网络拓扑结构网络图的凝聚性特征和R计算
weixin_39675926的博客
11-21 1286
网络拓扑结构-网络图的凝聚性特征前述网络基础概述中提到，在数学中，“网络”(networks)通常被称为“图”(graphs)，一个图G=(V,E)是一种包含“节点”集合V与“边”集合E的数学结构，其中E的元素是不同节点的无序组合{u,v}，u,v∈V。同时，对网络的基础要点做了简介。关于网络节点和边的特征，已在上篇作了简介，本篇继续在网络整体或局部水平上描述网络图结构，以及关注用于描述...
【算法概论】图论算法：无向图中的双连通分量划分问题
t11383的博客
05-19 978
问题描述： 给定一个无向图，设计一个算法，判断该图中是否存在关节点，并划分双连通分量。 ❗算法描述❗： 先明确几个概念： Let G be a connected graph: A separation vertex (articulation) 关节点of G is a vertex whose removal disconne...
基于C++的带权无向图的实现 （六）- 关节点算法
weixin_42375679的博客
02-14 1575
图的关节点算法的分析和代码实现。
最小生成树（Minimum Spanning Tree, MST）
最新发布
Rory的博客
07-01 892
以下是Prim算法在C++中的实现。这个实现使用了优先队列（堆）来选择权重最小的边，并逐步构建最小生成树。中，使得所有节点连通且总权重最小的一棵树。设置图的顶点和边，调用 Kruskal 算法并输出最小生成树。实现Prim算法，使用优先队列（最小堆）来选择最小权重的边。并查集实现，用于管理顶点集合，并支持路径压缩和按秩合并。以下是Kruskal算法在C++中的实现。：设置图的顶点和边，调用Prim算法并输出最小生成树。这个实现适用于任意无向加权图，并高效地找到最小生成树。Kruskal算法的实现。
数据结构 || 求连通图的关节点
perry0528的博客
01-23 2949
对图的存储结构基于无向图的邻接多重表。 关节点和重连通图： 假若在删去顶点v以及v相关联的各边之后，将图的一个连通分量分割成两个或两个以上的连通分量，则称顶点v为该图的一个关节点。 如果没有关节点的连通图则称为重连通图(双连通图)。 算法实现： 1. 方法一： 最简单也是最直接的算法是，删除一个点然后判断连通性，如果删除此点，图不再连通，则此点是关节点，反之不是关节点（图的连通性一般通过深搜来判定...
【霍罗维兹数据结构】GRAPH 图 | 基本图运算 DFS&BFS | 最小代价生成树
有道无术, 术尚可求。有术无道, 止于术。
06-02 1715
概念：最早可追溯到1736年，欧拉用图论解决了经典的七桥问题。欧拉证明，如果要从图中的一个节点除法，经图中所有边一次且仅一次，最后回到出发的节点，那么当且仅当图中所有节点的度都是偶数。为了纪念欧拉的发现，我们称之为欧拉回路。图是使用最广泛的数学结构，可应用于电路分析、寻找最短路径、项目规划、化合物鉴定、网络流程设计、基因/蛋白质相互作用等……一个图由两个集合构成： ：有限的、非空的顶点集合， ：有限的、可能是空的边缘集合。我们可以将其写作 .An undirected graph：each edg
算法设计技巧与分析（六）：图遍历(Graph Traversal)
m0_52935007的博客
12-07 1300
文章目录图遍历(Graph Traversal)一、深度优先搜索(Depth-First Search)二、寻找关节点(Finding Articulation Points in a Graph)三、广度优先搜索(Depth-First Search) 图遍历(Graph Traversal) 一、深度优先搜索(Depth-First Search) 深度优先搜索如下图所示： 图 算法伪代码如下： Input: 无向图G=(V, E); Output: 对应深度优先搜索树中顶点的预排序和后排序 pred
【图论】求无向连通图的割点
常胜将军的博客
01-14 1137
1. 割点与连通度 在无向连通图中，删除一个顶点v及其相连的边后，原图从一个连通分量变成了两个或多个连通分量，则称顶点v为割点，同时也称关节点(Articulation Point)。一个没有关节点的连通图称为重连通图(biconnected graph)。若在连通图上至少删去k 个顶点才能破坏图的连通性，则称此图的连通度为k。 关节点和重连通图在实际中较多应用。显然，一个表示
图论（二）：图的割点(cut vertex)与连通度(connectivity)
Machine Learning with Tutors
02-18 7434
在无向连通图中，删除一个顶点v及其相连的边后，原图从一个连通分量变成了两个或多个连通分量，则称顶点v为割点，同时也称关节点(Articulation Point)。一个没有关节点的连通图称为重连通图(biconnected graph)。若在连通图上至少删去k 个顶点才能破坏图的连通性，则称此图的连通度为k。关节点和重连通图在实际中较多应用。显然，一个表示通信网络的图的连通度越高，其系统越可靠，无论是哪一个站点出现故障或遭到外界破坏，都不影响系统的正常工作；
C#，图论与图算法，无向图断开点（Articulation Points）的算法与源代码
04-09
C#，图论与图算法，无向图断开点（Articulation Points）的算法与源代码 无向图断开点 如果移除无向连通图中的顶点（以及穿过该顶点的边）会断开该图，则该顶点是一个连接点（或切割顶点Cutting Point）。连接点表示...
无向图中的桥_C语言_codeblock.zip
05-03
无向图中的桥是图论中的一个重要概念，它在数据...在完成项目后，你不仅可以编写出检测无向图中桥的程序，还可以进一步扩展此程序，例如添加查找articulation points（割点）的功能，这同样依赖于DFS和时间戳的概念。
基于邻接链表构建的有向图
12-14
这些方法涵盖了有向图的基本操作和常见问题的解决，通过理解和实现这些方法，可以深入理解有向图的性质和应用。 三、邻接链表的优缺点 优点： 1. 空间效率高，尤其对于稀疏图。 2. 添加和删除顶点或边的时间复杂度...
用Prim算法求无向图的最小生成树 (2).pdf
06-23
最小生成树是指一个无环且连通的子图，它包含原图的所有顶点，并且边的权重之和尽可能小。在Prim算法中，我们逐步构建这个子图，每次添加一条连接已选顶点和未选顶点的最小权重边。 在给定的代码中，首先定义了最大...
visual-ads-help:一个用于构建，编辑和分析图形的网络工具
03-07
通过给定的邻接矩阵或邻接列表可视化图生成具有所需预定义属性的随机图 运行算法并可视化结果支持的算法： 查找树中心查找最短路径-Dijkstra's 查找最短路径-贝尔曼福特查找最小生成树查找牢固连接的组件寻找桥梁...
C++优先队列自定义排序总结
热门推荐
qq_40691051的博客
11-02 1万+
一、优先队的使用： 二、基本数据类型： priority_queue<int> q;//默认是从大到小 priority_queue<int, vector<int> ,less<int> >q;//从大到小排序 priority_queue<int, vector<int>, greater<int> >q...
强连通图------（1）通过两次DFS或BFS判断是不是强连通图
qq_40691051的博客
11-16 2935
一、定义： 强连通图（Strongly Connected Graph）是指在有向图G中，如果对于每一对vi、vj，vi≠vj，从vi到vj和从vj到vi都存在路径，则称G是强连通图。 二、判断是不是强连通图的算法： 下面是Kosaraju基于DFS的简单算法，这算法对图进行了两次DFS遍历： 1) 将所有顶点初始化为未访问。 2）从任意顶点v开始进行图的DFS遍历。如果DFS遍历没有访问完所有顶...
N划分成若干个奇正整数之和的分法有多少种---动态规划
qq_40691051的博客
11-23 1988
N划分成若干个奇正整数之和： 设f[i][j]表示将数i分成j个正奇数，g[i][j]表示将数i分成j个正偶数。 因为f[i][j]表示数i分成j个正奇数，假设把这j个划分每个加个1，因为奇数减加1即为偶数，所以这j个划分都变成了正偶数，所以把i-j划分成j个正奇数对应着把i划分成j个正偶数，即:f[i-j][j] = g[i][j] 同理可得：把i-j划分成j个正偶数对应着把i划分成j个正奇数，...
using namespace std;的陷阱
qq_40691051的博客
01-04 808
昨天遇到个很搞笑的问题 先贴代码 #include&amp;lt;iostream&amp;gt; void swap(int *a, int *b) { int temp = *a; *a = *b; *b = temp; } int main() { using namespace std; int a = 9, b = 8; cout &amp;lt;&amp;lt; &quot;before swap:&quot; &amp;lt;
python articulation points
10-16
在计算机科学中，图的关节点（Articulation Point）是指一个顶点，如果该顶点被移除后，图的连通性会发生改变，即图会变成无向图中的两个或更多个连通分量。Python可以用于找到图中的关节点。 要找到图中的关节点，...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值