Algorithms 第四版 习题 4.1.36 边连通性

4.1.36 Edge Connectivity 边连通性

定义：桥是如果从图中删去将生成两个子图的边。如果图中没有桥，则说该图是具有边连通性的。



图片源：http://moodle.bracu.ac.bd/mod/page/view.php?id=465

如上图，通过深度优先搜索DFS得到的一颗DFS 树。对任意子树的根，如B，要连通他的孩子们时，除了通过DFS生成的Tree edge，树边，还可以通过指向

B自己或者其祖先（这里只有A）的back edge，反向边；如果反向边不存在，那么一旦切断Tree edge，它就不能和（部分）孩子们连通了。这条Tree edge就是桥。

这里，对于B，它与以E为根的子树不是边连通的，因为BE是桥；它与以F为根的子树是边连通的，因为这颗子树存在反向边（指向B的父亲A）。

同理可知AD也是桥。

于是，判断图的边连通性只需要知道 每一个点 V 及 点V 的孩子们是否有反向边，这些反向边是否指向 点 V 或者 点V 的祖先 即可：

1. 用数组保存DFS对点的访问顺序。

2. 用数组保存反向边信息，这些信息在每层DFS会更新；在下层DFS返回后，判断当前点V 的访问顺序 是否小于 V孩子们的反向边指向的最远祖先，

是则表明 点V 到该 最远祖先之间不存在桥（因为总有反向边）；否则说明 V与它孩子的 tree edge就是桥。

如果要输出所有桥，时间复杂度就等于 O(DFS) = O ( |V| + |E| )；只需判断边连通性的话在找到一座桥时返回就可以了。

测试数据：

0: 6 2 1 5 

1: 0 

2: 0 

3: 5 4 

4: 5 6 3 

5: 3 4 0 

6: 0 4 

7: 8 

8: 7 

9: 11 10 12 

10: 9 

11: 9 12 

12: 11 9 

DFS结果是包含3棵树的树林

代码如下：

package com.cupid.algorithm.graph.algorithms4th;

import java.io.File;
import java.io.FileNotFoundException;
import java.util.Scanner;

// Algorithms 4th ed. 4.1.36
// Definition:
// A bridge in a graph is an edge that, if removed, would separate
// a connected graph into two disjoint subgraphs. A graph that has no bridges is said
// to be edge connected.2

public class EdgeConnectivity {
// The number of visit to each vertex during DFS.
private int[] dfsOrder;
// For any Vertex v, whichAncestor[v] tells that the farthest ancestor it can reach via its own or its children's back edge.
// If no back edge, it means it can only connect to parent through a DFS Tree edge.
private int[] whichAncestor;

private int count;
private Graph myGraph;

private boolean noBridges = true;

public EdgeConnectivity(Graph G){
this.myGraph = G;
count = 0;

dfsOrder = new int[G.V()];
whichAncestor = new int[G.V()];

for(int i=0;i<dfsOrder.length;i++){
dfsOrder[i] = 0;
}
}

private void DepthFirstSearch(){
for(int i=0;i<myGraph.V();i++)
if(dfsOrder[i] == 0){
dfs(i,i);
}
}

private void dfs(int u,int predecessor){
count = count + 1;
dfsOrder[u] = count;
// By default, no back edge connecting vertex u and any ancestor
whichAncestor[u] = count;

for(Integer v: myGraph.adj(u)){
// If adjacent vertex has not been visited...
if(dfsOrder[v] == 0){
dfs(v,u);
// When the next level of DFS returns,
// Update back edge information.
if(dfsOrder[u] >= whichAncestor[v]){
whichAncestor[u]  = whichAncestor[v];
// If, for vertex u, there is no back edge connecting its ancestors,
// A bridge exists, connecting u and its child, v.
}else{
noBridges = false;
System.out.println("A bridge is found:" + u + "-" + v);
}
// When dfsOrder[v] > 0, a back edge is found.
// Because there may be many back edges,
// we should update back edge information as the one to the farthest ancestor.
}else if(dfsOrder[v] > 0 && v!=predecessor){
if(dfsOrder[v] < whichAncestor[u])
whichAncestor[u] = dfsOrder[v];
}
}
}

public boolean isEdgeConnected(){
DepthFirstSearch();
return this.noBridges;
}

public static void main(String[] args) {
File file = new File("d:\\tinyG.txt");
try {
Scanner in = new Scanner(file);
Graph G = new Graph(in);
System.out.println(G);
EdgeConnectivity ec = new EdgeConnectivity(G);
System.out.println("\nIs the graph edge connected ? " + ec.isEdgeConnected());

}catch(FileNotFoundException e){
e.printStackTrace();
}
}

}

另外，与桥紧密相关的概念是 关节结点，可参考：http://www.csie.ntnu.edu.tw/~u91029/Connectivity.html