Articulation Points in Graph in DSA Rust

Introduction

Syntax

Examples

Sample Program

Important Notes

Summary

Practice

1. What is an articulation point in a graph?

easy

A. A vertex with the highest degree in the graph

B. A vertex that, when removed, increases the number of connected components

C. A vertex that has no edges connected to it

D. A vertex that forms a cycle with its neighbors

Solution

1. Step 1: Understand articulation point definition

   An articulation point is a vertex that, if removed, breaks the graph into more pieces (connected components).

2. Step 2: Compare options with definition

   Only A vertex that, when removed, increases the number of connected components matches this definition exactly.

3. Final Answer:

   A vertex that, when removed, increases the number of connected components -> Option B

4. Quick Check:

   Articulation point = vertex increasing components when removed [OK]

Hint: Articulation point breaks graph connectivity when removed [OK]

Common Mistakes:

• Confusing articulation point with highest degree vertex
• Thinking articulation point is a vertex with no edges
• Mixing articulation point with cycle forming vertex

2. Which Rust data structure is best suited to store the graph for finding articulation points?

easy

A. Vec (adjacency list)

B. HashMap

C. Vec<usize> (simple list)

D. String

Solution

1. Step 1: Identify graph representation for articulation points

   Graphs are commonly stored as adjacency lists for efficient traversal and edge lookup.

2. Step 2: Match Rust data structures

   Vec represents adjacency lists well, storing neighbors for each vertex.

3. Final Answer:

   Vec (adjacency list) -> Option A

4. Quick Check:

   Adjacency list = Vec in Rust [OK]

Hint: Use adjacency list (Vec of Vec) for graph edges [OK]

Common Mistakes:

• Using HashMap which is unrelated
• Using simple Vec<usize> which can't store edges
• Using String which is not a graph structure

3. What is the output of the following Rust code snippet that finds articulation points in a graph?

let graph = vec![
    vec![1, 2],
    vec![0, 2],
    vec![0, 1, 3],
    vec![2, 4],
    vec![3]
];
// Articulation points found: [2, 3]
println!("{:?}", find_articulation_points(&graph));

medium

A. [1, 4]

B. [0, 1]

C. [2, 3]

D. []

Solution

1. Step 1: Analyze graph structure

   Vertices 2 and 3 connect parts of the graph such that removing them increases components.

2. Step 2: Identify articulation points

   Removing vertex 2 disconnects vertex 3 and 4; removing vertex 3 disconnects vertex 4.

3. Final Answer:

   [2, 3] -> Option C

4. Quick Check:

   Vertices 2 and 3 are articulation points [OK]

Hint: Check vertices whose removal splits graph [OK]

Common Mistakes:

• Choosing vertices with no articulation role
• Ignoring connectivity after removal
• Assuming leaf nodes are articulation points

4. Identify the bug in this Rust code snippet for finding articulation points:

fn dfs(u: usize, graph: &Vec, visited: &mut Vec<bool>, disc: &mut Vec<usize>, low: &mut Vec<usize>, parent: &mut Vec, time: &mut usize) {
    visited[u] = true;
    disc[u] = *time;
    low[u] = *time;
    *time += 1;

    for &v in &graph[u] {
        if !visited[v] {
            parent[v] = Some(u);
            dfs(v, graph, visited, disc, low, parent, time);
            low[u] = low[u].min(low[v]);
        } else if v != parent[u].unwrap() {
            low[u] = low[u].min(disc[v]);
        }
    }
}

medium

A. Not updating low[v] after recursion

B. Not marking visited[u] as true

C. Not incrementing time variable

D. Using unwrap() on parent[u] without checking if it is Some

Solution

1. Step 1: Check unwrap usage on parent[u]

   parent[u] may be None for root node, unwrap() causes panic if None.

2. Step 2: Identify safe handling

   Code should check if parent[u] is Some before unwrap or handle root separately.

3. Final Answer:

   Using unwrap() on parent[u] without checking if it is Some -> Option D

4. Quick Check:

   Unsafe unwrap on Option causes runtime panic [OK]

Hint: Check Option unwrap safety for root node [OK]

Common Mistakes:

• Ignoring root node parent None case
• Assuming unwrap() is always safe
• Missing visited marking (actually present here)

5. Given a graph with multiple disconnected components, how should the articulation points algorithm be adapted in Rust to find all articulation points?

hard

A. Run DFS from every unvisited vertex to cover all components

B. Run DFS only from vertex 0 assuming graph is connected

C. Run BFS instead of DFS for articulation points

D. Ignore disconnected components as they have no articulation points

Solution

1. Step 1: Understand disconnected graph scenario

   Articulation points can exist in any component, so all must be checked.

2. Step 2: Adapt algorithm to run DFS on all components

   Run DFS from every unvisited vertex to cover all disconnected parts.

3. Final Answer:

   Run DFS from every unvisited vertex to cover all components -> Option A

4. Quick Check:

   Multiple DFS runs cover all components [OK]

Hint: Run DFS on all unvisited nodes for full coverage [OK]

Common Mistakes:

• Assuming graph is always connected
• Using BFS which doesn't track articulation points easily
• Ignoring disconnected components