提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档
前言
计算无向图割点和点双连通分量。注意点连通图和边连通图区别，例如2个顶点的简单无向连通图是点连通图，但不是边连通图。算法上也有一些细微差别。
一、点双连通分量？
一个无向图G是点双连通图，当且仅当删除任一个点v和其关联边后，图G保持连通性。计算无向图G的点连通分量C时，需要标记割点。每个割点v将图G分割成若干割点连通分量C。即两个点连通分量C1, C2没有公共边，但可能有公共割点v。
例如：下图的点b属于点连通分量C1, C2
C1 = {(e, b) (d, e) (b, d)}
C2 = {(c, a) (b, c) (a, b)}
二、DFS计算点连通分量算法
1.DFS算法
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() {
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();
}
}
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) {// 顶点u是割点或者根结点
if (adj[u].parent != -1) {// 顶顶u是非根结点
isCut[u] = true;
}
// 注意点双连通分量和边双连通分量区别，例如2个顶点的连通图是点双连通图，但不是边双连通
// 设根结点t，其子结点s， 条件adj[s].low >= adj[t].d = 1恒成立，所有该dfsVisit函数可以处理最后一个点双连通分量
bcc[++bccNum] = new LinkedList<>();// 点双连通分量的边结点链表
while (!stack.isEmpty()) {
Edge x = stack.pop();// 双连通分量中的边
bcc[bccNum].add(x);
if (x == e) {
break;
}
}
}
} 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 && childNum >= 2) {// 顶点u是树根结点且至少有两个子结点
isCut[u] = true;
}
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;
}
}
}
2.测试代码
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();
}
}
3.测试数据
输入：
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)}
扫一扫
2398
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
