1. Biconnected Graph Articulation Points

2. Biconnected Graph
A biconnected graph has at least 2 distinct paths (no common edges or vertices) between all vertex pairs
Any graph that is not biconnected has one or more articulation points
Vertices, that, if removed, will separate the graph
Any graph that has no articulation points is biconnected
Thus we can determine that a graph is biconnected if we look for, but do not find any articulation points

3. Finding articulation points
DFS pre-order traversal
Two arrays

4. DFS pre-order traversal
public Biconnected(Graph G) {
pre = new int[G.V()];
for (int v = 0; v < G.V(); v++)
pre[v] = -1;
if (pre[v] == -1)
dfs(G, v); }
private void dfs(Graph G, int v) {
pre[v] = cnt++;
for (int w : G.adj(v)) {
if (pre[w] == -1) {
dfs(G, w); }

5. DFS pre-order traversalM J B H D C K G I E L B F A M J D C G K I H E
private void dfs(Graph G, int v) {
pre[v] = cnt++;
for (int w : G.adj(v)) {
if (pre[w] == -1) {
dfs(G, w); }

6. DFS pre-order traversalM J B H D C K G I E L B F A M J D C G K I H E
private void dfs(Graph G, int v) {
pre[v] = cnt++;
for (int w : G.adj(v)) {
if (pre[w] == -1) {
dfs(G, w); }
pre: A L M J B H K G I D E C F 1 2 3 4 5 6 7 8 9 10 11 12 13

7. Finding articulation pointsM J B H D C K G I E
Finding articulation points
DFS pre-order traversal
Two arrays – pre[]
pre-order traversal order
pre[M]==3 means M is the 3rd node we visit
Node close to root should have smaller traversal order number
pre: A L M J B H K G I D E C F 1 2 3 4 5 6 7 8 9 10 11 12 13

8. Finding articulation pointsM J B H D C K G I E
Finding articulation points
Spanning tree edges
Back edges
private void dfs(Graph G, int v) {
pre[v] = cnt++;
for (int w : G.adj(v)) {
if (pre[w] == -1) {
// <v, w> is a spanning tree edge
dfs(G, w);
} else {
// <v, w> is a back edge since we have visited node w }

9. Finding articulation pointsM J B H D C K G I E
Finding articulation points
DFS pre-order traversal
Two arrays – low[]
Low[] records the earliest ancestor a node and its children could reach
For spanning tree edge (v, w), low[w] >= pre[v] means v is a articulation point
Since the earliest ancestor of w is v, it could not be earlier than v A L M J B H K G I D E C F
pre 1 2 3 4 5 6 7 8 9 10 11 12 13
low

10. Finding articulation pointsM J B H D C K G I E
Low[v] records the earliest ancestor node v and its children could reach
Min of three cases
1) Basic case: low[v] = prev[v]
Node v could reach itself v

11. Finding articulation pointsM J B H D C K G I E
Low[v] records the earliest ancestor node v and its children could reach
Min of three cases
2) v has back edges (v, w):
Compare pre[w] to low[v]
E.g. node G choose B among {K, H, B}
When we search from node v, we know pre[w] since we already visited the node
w could not be parent of v w v A L M J B H K G I D E C F
pre 1 2 3 4 5 6 7 8 9 10 11 12 13
low

12. Finding articulation pointsM J B H D C K G I E
Low[v] records the earliest ancestor node v and its children could reach
Min of three cases
3) v has spanning tree edges (v, w):
Compare low[w] to low[v]
E.g. node M choose A since its children B and C could reach A
When we search from node v, we DONOT know low[w] since just plan to visit it in the next recursive call w v A L M J B H K G I D E C F
pre 1 2 3 4 5 6 7 8 9 10 11 12 13
low

13. Finding articulation pointsM J B H D C K G I E
Min of three cases
1) Basic case:
low[v] = prev[v]
2) v has back edges (v, w):
compare pre[w] to low[v], e.g. node G
3) v has spanning tree edges (v, w):
compare low[w] to low[v], e.g. node M
For the case 3), we have to make the comparison after recursive call, since then we have information of low[w]
Decide the low[] value of leaf node at the beginning
Update low[] in the path
E.g. Only when we know low[C]=1, we would update low[B]=1, then low[M]=1, low[L]=1

14. private void dfs(Graph G, int u, int v) { int children = 0; pre[v] = cnt++; low[v] = pre[v]; for (int w : G.adj(v)) { if (pre[w] == -1) { children++; dfs(G, v, w); low[v] = Math.min(low[v], low[w]); if (low[w] >= pre[v] && u != v) articulation[v] = true; } else if (w != u) low[v] = Math.min(low[v], pre[w]); } if (u == v && children > 1)
Case 1: basic
public Biconnected(Graph G) {
low = new int[G.V()];
pre = new int[G.V()];
articulation = new boolean[G.V()];
for (int v = 0; v < G.V(); v++)
low[v] = -1;
pre[v] = -1;
if (pre[v] == -1)
dfs(G, v, v); }
Case 3: spanning tree edge
The condition
Case 2: back edge

15. A L F M J B H D C K G I E A L M J B H K G I D E C F pre 1 2 3 4 low A5 6 7 8 9
low A L M J B H K G I D E C F
pre 1 2 3 4 5 6 7 8 9
low A L M J B H K G I D E C F
pre 1 2 3 4 5 6 7 8 9 10 11
low

16. A L F M J B H D C K G I E A L M J B H K G I D E C F pre 1 2 3 4 5 6 78 9 10 11
low A L F M J B H D C K G I E A L M J B H K G I D E C F
pre 1 2 3 4 5 6 7 8 9 10 11
low A L M J B H K G I D E C F
pre 1 2 3 4 5 6 7 8 9 10 11 12
low A L M J B H K G I D E C F
pre 1 2 3 4 5 6 7 8 9 10 11 12
low A L M J B H K G I D E C F
pre 1 2 3 4 5 6 7 8 9 10 11 12 13
low