Articulation Points in Graph in DSA Rust - Build from Scratch

Articulation Points in Graph

📖 Scenario: Imagine a city's road network represented as a graph. Each intersection is a node, and each road is an edge connecting two intersections. Some intersections are critical: if they close, parts of the city become unreachable. These are called articulation points.

🎯 Goal: You will build a Rust program to find all articulation points in a given undirected graph. This helps identify critical intersections in the city road network.

📋 What You'll Learn

Create a graph using adjacency lists with exact nodes and edges

Create variables to track discovery times and low values for each node

Implement a depth-first search (DFS) to find articulation points using Tarjan's algorithm

Print the list of articulation points found in the graph

💡 Why This Matters

🌍 Real World

Finding articulation points helps city planners identify critical intersections that need reinforcement or alternative routes to avoid traffic jams or isolation.

💼 Career

Understanding graph algorithms like articulation points is essential for roles in network design, infrastructure planning, cybersecurity, and software engineering involving complex data relationships.

1

Create the graph adjacency list

Create a variable called graph as a Vec> with 5 nodes (0 to 4) and these edges: 0-1, 0-2, 1-2, 1-3, 3-4.

DSA Rust

# Your code here to create the graph adjacency list

Hint

Use a vector of vectors to represent the graph. Add edges in both directions because the graph is undirected.

2

Create tracking variables for DFS

Add these variables after the graph: let mut time = 0;, let mut disc = vec![-1; 5];, let mut low = vec![-1; 5];, and let mut articulation_points = vec![false; 5];.

DSA Rust

fn main() {
    let mut graph: Vec> = vec![vec![], vec![], vec![], vec![], vec![]];
    graph[0].push(1);
    graph[0].push(2);
    graph[1].push(0);
    graph[1].push(2);
    graph[1].push(3);
    graph[2].push(0);
    graph[2].push(1);
    graph[3].push(1);
    graph[3].push(4);
    graph[4].push(3);

    // Add variables time, disc, low, articulation_points here
    # Your code here
}

Hint

Use vectors of length 5 initialized with -1 for discovery and low times, and false for articulation points.

3

Implement DFS function to find articulation points

Define a function dfs with parameters u: usize, parent: Option, graph: &Vec>, time: &mut i32, disc: &mut Vec, low: &mut Vec, and articulation_points: &mut Vec. Implement Tarjan's algorithm inside it to update disc, low, and articulation_points. Then call dfs(0, None, &graph, &mut time, &mut disc, &mut low, &mut articulation_points); inside main.

DSA Rust

    fn dfs(
        u: usize,
        parent: Option,
        graph: &Vec>,
        time: &mut i32,
        disc: &mut Vec,
        low: &mut Vec,
        articulation_points: &mut Vec,
    ) {
        *time += 1;
        disc[u] = *time;
        low[u] = *time;
        let mut children = 0;
        for &v in &graph[u] {
            if disc[v] == -1 {
                children += 1;
                dfs(v, Some(u), graph, time, disc, low, articulation_points);
                low[u] = low[u].min(low[v]);
                if parent.is_none() && children > 1 {
                    articulation_points[u] = true;
                }
                if parent.is_some() && low[v] >= disc[u] {
                    articulation_points[u] = true;
                }
            } else if Some(v) != parent {
                low[u] = low[u].min(disc[v]);
            }
        }
    }
    dfs(0, None, &graph, &mut time, &mut disc, &mut low, &mut articulation_points);
    // Print articulation points here

Hint

Use recursion to visit nodes. Update discovery and low times. Mark articulation points based on Tarjan's rules.

4

Print the articulation points

Add a for loop in main to print all node indices where articulation_points[node] is true. Print each node on its own line.

DSA Rust

Hint

Loop through all nodes and print those marked as articulation points.

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