无向图的边双连通分量

割点、桥以及边双连通分量

设G = (V, E)是一个无向连通图，如果去掉G的某个顶点后G就不再是连通图了，这样的顶点称为割点(articulation point)。如果去掉某一边后，G就不在连通了，这样的边称为桥(bridge)。G的双连通分支（biconnected component）是满足以下条件的一个最大边集，即该集合中的任意两条边都位于同一个公共简单回路上。

算法思路

设 low[v] = min { d[v], d[w]: 对v的后裔u，(u, w)是反向边 }
证明G的边双连通分支划分了G的非桥边。

算法实现

package graph;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.ListIterator;
import java.util.Stack;

public class BiConnectedComponent<V, E> {
	private static final int WHITE = 0;
	private static final int GRAY = 1;
	private static final int BLACK = 2;
	private Vertex<V>[] adj;// 邻接表
	private int n;// 顶点数目
	private int m;// 边数
	private int time = 0;
	private boolean isCut[];// 割点
	private LinkedList<Edge>[] bcc;// 边双连通分量
	private int bccNum = 0;
	private Stack<Edge> stack;// 边结点栈

	@SuppressWarnings("unchecked")
	BiConnectedComponent(int capacity) {
		adj = new Vertex[capacity];
		n = 0;
	}

	public void addVertex(int v, V value) {
		adj[v] = new Vertex<>(value);
		n++;
	}

	public void addEdge(int u, int v) {
		addEdge(u, v, null);
	}

	public void addEdge(int u, int v, E value) {
		Edge prev = null;//
		for (Edge curr = adj[u].firstEdge; curr != null; curr = curr.next) {
			if (v == curr.v) {
				curr.value = value;
				return;
			} else if (v < curr.v) {
				if (prev == null) {
					adj[u].firstEdge = new Edge<E>(u, v, value, curr);
				} else {
					prev.next = new Edge<E>(u, v, value, curr);
				}

				return;
			}

			prev = curr;
		}

		// 插入到链表尾部
		if (prev == null) {
			adj[u].firstEdge = new Edge<E>(u, v, value, null);// 第一个边结点
		} else {
			prev.next = new Edge<E>(u, v, value, prev.next);// 插入到边链表的尾部
		}
	}

	public BiConnectedComponent<V, E> transpose() {
		BiConnectedComponent<V, E> tgraph = new BiConnectedComponent<>(adj.length);// 转置图
		for (int u = 0; u < adj.length; u++) {
			tgraph.addVertex(u, adj[u].value);
		}

		for (int u = 0; u < adj.length; u++) {
			for (Edge e = adj[u].firstEdge; e != null; e = e.next) {
				int v = e.v;// <u, v > transpose to <v, u>
				tgraph.addEdge(v, u);
			}
		}

		return tgraph;
	}

	public void initialize() {
		time = 0;
		bccNum = 0;
		for (int u = 0; u < adj.length; u++) {
			adj[u].color = WHITE;
			adj[u].parent = -1;
			adj[u].d = 0;
			adj[u].f = 0;
			adj[u].low = 0;
		}
	}

	/**
	 * 计算双连通分量
	 * 
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public int biConnectedComponent() {
		initialize();
		isCut = new boolean[n];// 割点标志
		bcc = new LinkedList[n];// 双连通分支
		stack = new Stack<>();// 边结点栈
		for (int u = 0; u < n; u++) {
			if (adj[u].color == WHITE) {
				dfsVisit(u);
			}
		}

		return bccNum;// 双连通分支数目
	}
	
	/**
	 * 打印边双连通分量
	 */
	public void printBiConnectedComponent() {
		if (bccNum == 0) {
			System.out.println("no edge biconnected components");
			return;
		}

		for (int i = 1; i <= bccNum; i++) {
			ListIterator<Edge> itr = bcc[i].listIterator();
			System.out.print("{");
			if (itr.hasNext()) {// 第一条边
				Edge e = itr.next();
				System.out.print("(" + adj[e.u].value + ", " + adj[e.v].value + ")");
			}

			while (itr.hasNext()) {// 其他边
				Edge e = itr.next();
				System.out.print(" (" + adj[e.u].value + ", " + adj[e.v].value + ")");
			}
			System.out.print("}");
			System.out.println();
		}
	}
	
	/**
	 * 深度优先搜索，标记割点，判定桥，记录边双连通分量
	 * @param u
	 */
	void dfsVisit(int u) {
		int childNum = 0;
		adj[u].color = GRAY;
		adj[u].d = ++time;
		adj[u].low = adj[u].d;
		for (Edge e = adj[u].firstEdge; e != null; e = e.next) {
			int v = e.v;// <u, v>
			if (adj[v].color == WHITE) {
				childNum++;// 子结点数目
				adj[v].parent = u;
				stack.push(e);// 树边进栈
				dfsVisit(v);// 计算顶点v的low值
				if (adj[v].low < adj[u].low) {
					adj[u].low = adj[v].low;// 顶点u后代的low值
				}

				// 有一个子结点v，使得不存在从v或者v的任何后代指向u的某个真祖先的反向边
				if (adj[v].low >= adj[u].d && adj[u].parent != -1) {// 非根顶点u是割点
					isCut[u] = true;
				}

				if (adj[v].low > adj[u].d) {// 边e(u, v)是桥，注意和割点判断条件区别
					//当从桥e的端点v递归回升到端点u时，记录端点v所属的边双连通分量
					// 注意点双连通分量和边双连通分量区别，例如2个顶点的连通图是点双连通图，但不是边双连通
					Edge x = stack.pop();// 判断栈顶元素是否为非桥边
					if (x != e) {
						bcc[++bccNum] = new LinkedList<>();// 点双连通分量的边结点链表
						while (!stack.isEmpty() && x != e) {
							bcc[bccNum].add(x);// 添加非桥边
							x = stack.pop();// 取出下一条边
						}
					}
				}
			} else if (adj[v].d < adj[u].d && adj[u].parent != v) {// 反向边
				stack.push(e);// 反向边是非桥边
				if (adj[v].d < adj[u].low) {
					adj[u].low = adj[v].d;// 顶点u祖先的发现时间
				}
			}
		}

		// 对树根的处理
		if (adj[u].parent == -1) {
			// 顶点u是树根结点且至少有两个子结点
			if (childNum >= 2) {
				isCut[u] = true;
			}

			// 如果存在桥边e, 则在dfsVisit函数递归回升到e的起点u时，桥边e出栈，所以最后栈中剩下的边都是非桥边
			if (!stack.isEmpty()) {
				bcc[++bccNum] = new LinkedList<>();// 点双连通分量的边结点链表
			}
			while (!stack.isEmpty()) {
				Edge x = stack.pop();
				bcc[bccNum].add(x);// 添加非桥边
			}
		}
		adj[u].color = BLACK;
	}

	public void printAdjList() {
		StringBuilder vs = new StringBuilder();
		StringBuilder es = new StringBuilder();
		boolean wrc = false;
		vs.append("{");
		es.append("{");
		for (int i = 0; i < n; i++) {
			vs.append(adj[i].value);
			if (i < n - 1) {
				vs.append(", ");
			}

			for (Edge p = adj[i].firstEdge; p != null; p = p.next) {
				if (wrc)
					es.append(", ");
				es.append("(");
				es.append(adj[i].value);
				es.append(", ");
				es.append(adj[p.v].value);
				es.append(")");
				wrc = true;
			}
		}
		vs.append("}");
		es.append("}");
		System.out.println(vs);
		System.out.println(es);
	}

	static class Vertex<V> {
		int color;
		int d;// discover time
		int f;// finished time
		V value;
		Edge firstEdge;// 第一条边
		int parent;// 前驱顶点
		int low;// 最小祖先结点的发现时间

		Vertex(V value) {
			super();
			this.value = value;
		}

		@Override
		public String toString() {
			return "" + value + "";
		}

	}

	static class Edge<E> {
		int u;// 起点
		int v;// 终点
		E value;
		Edge<E> next;// 下一条边

		Edge(int u, int v, E value, Edge<E> next) {
			super();
			this.u = u;
			this.v = v;
			this.value = value;
			this.next = next;
		}

	}

}

测试代码

package graph;

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class TestBiConnectedComponent {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int m = in.nextInt();
		in.nextLine();

		BiConnectedComponent<Character, Object> graph = new BiConnectedComponent<>(n);
		for (int i = 0; i < n; i++) {
			graph.addVertex(i, (char) ('a' + i));
		}

		Pattern pattern = Pattern.compile("\\(([a-z]), ([a-z])\\)");
		for (int i = 0; i < m; i++) {
			String s = in.nextLine();
			Matcher matcher = pattern.matcher(s);
			while (matcher.find()) {
				// pair (u, v)
				int u = matcher.group(1).charAt(0) - 'a';
				int v = matcher.group(2).charAt(0) - 'a';
				graph.addEdge(u, v);
				graph.addEdge(v, u);
			}
		}

		graph.biConnectedComponent();// 计算双连通分量
		graph.printBiConnectedComponent();

	}

}

测试案例

test case #1:
5 6
(a, b)
(a, c)
(b, c)
(b, d)
(b, e)
(d, e)
{(e, b) (d, e) (b, d) (c, a) (b, c) (a, b)}

test case #2:
input:
6 7
(a, b)
(a, c)
(b, c)
(b, d)
(d, e)
(d, f)
(e, f)

result:
{(f, d) (e, f) (d, e)}
{(c, a) (b, c) (a, b)}