Biconnected Graph Articulation Points

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

Finding articulation points DFS pre-order traversal Two arrays

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); }

DFS pre-order traversal M 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); }

DFS pre-order traversal M 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); } 1-based counting 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

Finding articulation points M 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

Finding articulation points M 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 already visited node w }

Finding articulation points M 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 E.g. (B, D) 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

Finding articulation points M 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 Def: Low[] records the earliest ancestor a node and its children could reach v

Finding articulation points M 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] fix v, for all w 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 the 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

Finding articulation points M 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 could reach A What if children of B could have smaller low value? When we search from node v, we DO NOT know low[w] until we return from the next recursive call 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 w

Finding articulation points M 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 could finally decide that low[B]=1, then low[M]=1, low[L]=1

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 Special case for root node

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 (1, 1) A L F M J B H D C K G I E (2, 2) A L M J B H K G I D E C F pre 1 2 3 4 low (3, 3) (3, 2) (5, 5) A L M J B H K G I D E C F pre 1 2 3 4 5 6 7 8 9 low (4, 2) (6, 6) (6, 5) A L M J B H K G I D E C F pre 1 2 3 4 5 6 7 8 9 low (10, 10) (7, 7) (11, 5) (7, 5) (8, 5) 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 (9, 9)

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 (1, 1) A L F M J B H D C K G I E (13, 13) (2, 2) (2, 1) 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 (3, 3) (3, 2) (3, 1) (5, 5) 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 (4, 2) (5, 1) (12, 1) (6, 6) (6, 5) 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 (10, 10) (7, 7) (10, 5) (11, 5) (7, 5) (8, 5) 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 (9, 9)