Articulation Points in Graph in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the discovery time vector with -1 for all vertices.

DSA Rust

let mut disc = vec![-1; [1]];

Drag options to blanks, or click blank then click option'

Agraph.len()

Bgraph[0].len()

Cgraph.capacity()

Dgraph.size()

Attempts:

3 left

💡 Hint

Common Mistakes

Using graph[0].len() which gives the number of neighbors of the first vertex, not total vertices.

Using graph.capacity() which is unrelated to vertex count.

The discovery time vector should have one entry per vertex, so its length must be the number of vertices, which is graph.len().

2fill in blank

medium

Complete the code to update the low time of u after visiting neighbor v.

DSA Rust

low[u] = std::cmp::min(low[u], [1]);

Drag options to blanks, or click blank then click option'

Adisc[v]

Btime

Clow[v]

Ddisc[u]

Attempts:

3 left

💡 Hint

Common Mistakes

Using disc[v] instead of low[v], which ignores back edges reachable from v.

Using disc[u] which does not update low[u] correctly.

The low[u] value is updated to the minimum of its current value and low[v], which represents the earliest visited vertex reachable from v.

3fill in blank

hard

Fix the error in the condition to check if u is an articulation point when u is not root.

DSA Rust

if parent[u] != -1 && low[v] >= [1] {

Drag options to blanks, or click blank then click option'

Aparent[u]

Blow[u]

Cdisc[v]

Ddisc[u]

Attempts:

3 left

💡 Hint

Common Mistakes

Comparing low[v] with low[u] which is incorrect for articulation point check.

Using disc[v] which is unrelated here.

The condition low[v] >= disc[u] means that v or its descendants cannot reach an ancestor of u, so u is an articulation point.

4fill in blank

hard

Fill both blanks to correctly implement the DFS call and update the child count.

DSA Rust

for &v in &graph[u] {
    if disc[v] == -1 {
        parent[v] = u;
        [1](v, time, disc, low, parent, ap, graph);
        children += 1;
    }
}

Drag options to blanks, or click blank then click option'

Adfs

Bbfs

Cvisit

Dsearch

Attempts:

3 left

💡 Hint

Common Mistakes

Using bfs which is breadth-first search, not suitable here.

Using undefined function names like visit or search.

The DFS function is called recursively on vertex v to explore its subtree.

5fill in blank

hard

Fill all three blanks to correctly check and mark the root as an articulation point.

DSA Rust

if parent[u] == -1 && [1] > [2] {
    ap[u] = [3];
}

Drag options to blanks, or click blank then click option'

Achildren

B1

Ctrue

Dfalse

Attempts:

3 left

💡 Hint

Common Mistakes

Using false instead of true for ap[u].

Comparing children with 0 instead of 1.

If u is root (parent[u] == -1) and has more than one child, it is an articulation point, so ap[u] is set to true.

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