图—双连通性

最新推荐文章于 2024-04-06 23:12:25 发布

thdwx

最新推荐文章于 2024-04-06 23:12:25 发布

阅读量743

点赞数 1

分类专栏： C/C++ 文章标签： 1024程序员节 c语言数据结构算法图论

本文链接：https://blog.csdn.net/thdwx/article/details/127496989

版权

C/C++ 专栏收录该内容

71 篇文章 0 订阅

订阅专栏

如果一个无向连通图 $G=(V,E)$ ，对于图中任何一个顶点 $S$ ，使得删除 $S$ 后，图中剩余部分仍然连通，这样的无向图就是双连通的。如果双连通图中的节点是计算机，边是链路，那么任何一台计算机出现故障都不会造成其他计算机之间的无法通讯；如果双连通图是交通系统，那么就算某个站点被破坏，依然是可以到达其他站点的。

如果一个无向图不是双连通的，那么删除后使得图不再连通的顶点就叫做割点，这些节点在许多应用中都是很重要的。

深度优先搜索提供了一种找到连通图中所有割点的线性时间算法。首先，从图中任意顶点开始执行深度优先搜索，并在每个顶点被访问时给它编号。对于每一个顶点 $v$ ，我们称其先序编号为 $Num(v)$ 。然后，对深度优先搜索生成树的每一个顶点 $v$ ，我们计算出 $v$ 所能达到的最低（小）编号 $Low(v)$ （在原图中），该最低点可能从 $v$ 出发的一条前向边或是一条背向边到达。

以上图为例，首先深度优先搜索得到深度优先搜索生成树。然后，我们从A顶点出发，A，B，C，D顶点所能到达的最低顶点都是A(1)，因为它们都能通过D的一条背向边到达A，所以它们的 $Low(v)=1$ ，再对其余顶点做同样的分析，就可以得到所有顶点的 $Low(v)$ ，下图是最后的结果：

根据 $Low(v)$ 的定义可知， $Low(v)$ 是：

1. $Num(v)$

2.所有背向边中最小的 $Num(w)$ （如果有背向边）

3.树的所有边中最小的 $Low(w)$ （实际上是所有前向边中最小的 $Low(w)$ ，因为背向边不属于树的边（如果有前向边）

三者中的最小者。

由 $Low(v)$ 的定义可知，我们需要直到 $v$ 的所有子节点的 $Low(w)$ ，才能得到 $v$ 的 $Low(v)$ ，所以这是一个后序遍历，因为要处理 $v$ 的所有子节点后才能得到 $Low(v)$ 。判断割点的法则是：在深度优先搜索生成树上，对于顶点 $v$ ，当且仅当有某个子节点 $w$ ，使得 $Low(w)\geq Num(v)$ 时， $v$ 为割点。“当”是显然成立的，因为当这个条件成立时，说明 $v$ 节点之后的节点无法通过一条背向边回到 $v$ 之前的节点，那么删除 $v$ 后，图中就不存在一个顶点可以到达这个 $w$ 顶点；下面大概说明“仅当”，假设有一个割点 $v$ ，并且其所有子节点都有 $Low(w)<Num(v)$ ，由 $Num()$ 与 $Low()$ 的定义可知，一定存在 $w$ 能到达的一个顶点 $s$ ，这个顶点的 $Num(s)<Num(v)$ ，那么就说明在深度优先搜索生成树中， $s$ 在 $v$ 的上方，当删除割点 $v$ 后，显然存在一条背向边 $(w,s)$ 可以变为一条前向边 $(s,w)$ 使图连通，所以“仅当”也是成立的。

根据上述说明，要得到一个无向连通图中的割点，首先要进行一次深度优先搜索来得到所有的 $Num(v)$ ，再通过一次后序遍历来得到所有的 $Low(v)$ ，最后再找出符合条件的节点，这总共需要三次遍历。但实际上，不存在一个遍历一定是后序或是先序遍历，如果在后序遍历之前对当前顶点进行操作，那么这个遍历也就既是后序也是先序，所以可以使用一次遍历就找到图中的割点。显然，我们需要遍历所有的顶点和边才能找到割点，所以这个算法的时间复杂度为 $O(|E|+|V|)$ 。但要注意：上面提到的判断条件在任何时候对根节点都是有效的，但根节点只有在有两个及以上孩子的情况下才是割点，所以对根结点的判断要另外进行。以上图为例，给出找到所有割点的代码：

int count = 1;//定义全局变量方便编号

void FindArt(g* p, int v) {
	p->arr[v]->Num = count++;//先给选定的根节点编号1，然后count+1
	p->arr[v]->visited = 1;//标为已知
	l* tmp = p->arr[v]->next;
	p->arr[v]->Low = p->arr[v]->Num;//先将Num赋值给Low，因为到这一步只有Num的值
	while (tmp != NULL) {//对于每个邻接顶点
		if (p->arr[tmp->val]->visited == 0) {//如果没访问过，就说明是前向边
			p->arr[tmp->val]->parent = v;//将其父亲节点标记为v
			FindArt(p, tmp->val);//找到该节点的Num以及Low
			if (p->arr[tmp->val]->Low >= p->arr[v]->Num && v != 0) {//当该节点的Low满足条件，就说明v是割点
				printf("%c 是割点\n", 'A' + v);
			}
			else {//否则，就将Low的值改变为更小的值
				p->arr[v]->Low = p->arr[tmp->val]->Low;
			}
		}
		else {//如果以经被访问过，说明要么是父亲节点，要么是背向边
			if (p->arr[v]->parent != tmp->val) {//判断为背向边，满足条件就改变为更小值
				p->arr[v]->Low = p->arr[v]->Low < p->arr[tmp->val]->Num ? p->arr[v]->Low : p->arr[tmp->val]->Num;
			}
		}
		tmp = tmp->next;
	}
}

void RootIsArt(g* p) {//判断根节点是否是割点
	int cnt = 0;//只要根节点的子节点数小于2即可
	for (int i = 0; i < 7; i++) {
		if (p->arr[i]->parent == 0)
			cnt++;
	}
	if (cnt >= 2)
		printf("A 是割点\n");
	else
		printf("A 不是割点\n");
}

图的建立及测试代码：

#include <stdio.h>
#include <stdlib.h>

//邻接表，存放邻接顶点的名称
typedef struct list {
	int val;
	struct list* next;
}l;

//存放图中每个顶点信息的结构
typedef struct table {
	int Num;
	int Low;
	int visited;
	int parent;
	l* next;
}t;

//图，含有指向每个顶点信息的指针
typedef struct graph {
	t* arr[7];
}g;

//建立图
g* CreatGraph() {
	g* pg = (g*)malloc(sizeof(g));
	for (int i = 0; i < 7; i++) {
		t* pt = (t*)malloc(sizeof(t));
		pt->Low = 0;
		pt->next = NULL;
		pt->Num = 0;
		pt->visited = 0;
		pg->arr[i] = pt;
	}

	l* p = (l*)malloc(sizeof(l));
	p->val = 1;
	p->next = pg->arr[0]->next;
	pg->arr[0]->next = p;
	p = (l*)malloc(sizeof(l));
	p->val = 3;
	p->next = pg->arr[0]->next;
	pg->arr[0]->next = p;

	p = (l*)malloc(sizeof(l));
	p->val = 0;
	p->next = pg->arr[1]->next;
	pg->arr[1]->next = p;
	p = (l*)malloc(sizeof(l));
	p->val = 2;
	p->next = pg->arr[1]->next;
	pg->arr[1]->next = p;

	p = (l*)malloc(sizeof(l));
	p->val = 1;
	p->next = pg->arr[2]->next;
	pg->arr[2]->next = p;
	p = (l*)malloc(sizeof(l));
	p->val = 3;
	p->next = pg->arr[2]->next;
	pg->arr[2]->next = p;
	p = (l*)malloc(sizeof(l));
	p->val = 6;
	p->next = pg->arr[2]->next;
	pg->arr[2]->next = p;

	p = (l*)malloc(sizeof(l));
	p->val = 0;
	p->next = pg->arr[3]->next;
	pg->arr[3]->next = p;
	p = (l*)malloc(sizeof(l));
	p->val = 2;
	p->next = pg->arr[3]->next;
	pg->arr[3]->next = p;
	p = (l*)malloc(sizeof(l));
	p->val = 4;
	p->next = pg->arr[3]->next;
	pg->arr[3]->next = p;
	p = (l*)malloc(sizeof(l));
	p->val = 5;
	p->next = pg->arr[3]->next;
	pg->arr[3]->next = p;

	p = (l*)malloc(sizeof(l));
	p->val = 3;
	p->next = pg->arr[4]->next;
	pg->arr[4]->next = p;
	p = (l*)malloc(sizeof(l));
	p->val = 5;
	p->next = pg->arr[4]->next;
	pg->arr[4]->next = p;

	p = (l*)malloc(sizeof(l));
	p->val = 3;
	p->next = pg->arr[5]->next;
	pg->arr[5]->next = p;
	p = (l*)malloc(sizeof(l));
	p->val = 4;
	p->next = pg->arr[5]->next;
	pg->arr[5]->next = p;

	p = (l*)malloc(sizeof(l));
	p->val = 2;
	p->next = pg->arr[6]->next;
	pg->arr[6]->next = p;

	return pg;
}


int main() {
	g* p = CreatGraph();

	FindArt(p, 0);

	RootIsArt(p);

	return 0;
}

thdwx

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
1
评论
图—双连通性

但实际上，不存在一个遍历一定是后序或是先序遍历，如果在后序遍历之前对当前顶点进行操作，那么这个遍历也就既是后序也是先序，所以可以使用一次遍历就找到图中的割点。然后，我们从A顶点出发，A，B，C，D顶点所能到达的最低顶点都是A(1)，因为它们都能通过D的一条背向边到达A，所以它们的。如果一个无向图不是双连通的，那么删除后使得图不再连通的顶点就叫做割点，这些节点在许多应用中都是很重要的。根据上述说明，要得到一个无向连通图中的割点，首先要进行一次深度优先搜索来得到所有的。使图连通，所以“仅当”也是成立的。
复制链接

扫一扫