Bird
Raised Fist0
DSA Rustprogramming~10 mins

Minimum Spanning Tree Kruskal's Algorithm in DSA Rust - Interactive Practice

Choose your learning style10 modes available
Practice - 5 Tasks
Answer the questions below
1fill in blank
easy

Complete the code to sort edges by weight in Kruskal's algorithm.

DSA Rust
edges.sort_by_key(|edge| edge.[1]);
Drag options to blanks, or click blank then click option'
Anode2
Bnode1
Cweight
Dindex
Attempts:
3 left
💡 Hint
Common Mistakes
Sorting by node1 or node2 instead of weight.
Not sorting edges at all.
2fill in blank
medium

Complete the code to find the parent of a node in the union-find structure.

DSA Rust
fn find_parent(parents: &mut Vec<usize>, node: usize) -> usize {
    if parents[node] != node {
        parents[node] = find_parent(parents, [1]);
    }
    parents[node]
}
Drag options to blanks, or click blank then click option'
Anode
Bnode + 1
C0
Dparents[node]
Attempts:
3 left
💡 Hint
Common Mistakes
Using node instead of parents[node] in recursion.
Using a fixed number like 0 or node+1.
3fill in blank
hard

Fix the error in the union function to correctly merge two sets.

DSA Rust
fn union(parents: &mut Vec<usize>, ranks: &mut Vec<usize>, a: usize, b: usize) {
    let root_a = find_parent(parents, a);
    let root_b = find_parent(parents, b);
    if root_a != root_b {
        if ranks[root_a] < ranks[root_b] {
            parents[root_a] = [1];
        } else if ranks[root_a] > ranks[root_b] {
            parents[root_b] = root_a;
        } else {
            parents[root_b] = root_a;
            ranks[root_a] += 1;
        }
    }
}
Drag options to blanks, or click blank then click option'
Aroot_b
Broot_a
Ca
Db
Attempts:
3 left
💡 Hint
Common Mistakes
Assigning parents[root_a] to root_a or a wrong node.
Mixing up root_a and root_b in assignment.
4fill in blank
hard

Fill both blanks to add edges to MST and update total weight.

DSA Rust
if find_parent(&mut parents, edge.node1) != find_parent(&mut parents, edge.node2) {
    union(&mut parents, &mut ranks, edge.node1, edge.node2);
    mst_edges.push([1]);
    total_weight [2] edge.weight;
}
Drag options to blanks, or click blank then click option'
Aedge
Bedge.weight
C+=
D-=
Attempts:
3 left
💡 Hint
Common Mistakes
Pushing edge.weight instead of edge.
Using '-=' instead of '+=' for total_weight.
5fill in blank
hard

Fill all three blanks to create a vector of parents, ranks, and initialize MST edges.

DSA Rust
let mut parents = (0..[1]).collect::<Vec<usize>>();
let mut ranks = vec![[2]; [3]];
let mut mst_edges = Vec::new();
Drag options to blanks, or click blank then click option'
Anum_nodes
B0
D1
Attempts:
3 left
💡 Hint
Common Mistakes
Initializing ranks with 1 instead of 0.
Using wrong size for vectors.

Practice

(1/5)
1. What is the main goal of Kruskal's Algorithm in graph theory?
easy
A. To sort the vertices of a graph
B. To find the minimum spanning tree of a graph
C. To detect cycles in a graph
D. To find the shortest path between two nodes

Solution

  1. Step 1: Understand the purpose of Kruskal's Algorithm

    Kruskal's Algorithm is designed to find a subset of edges that connects all vertices with the minimum total edge weight and no cycles.
  2. Step 2: Compare with other graph algorithms

    Unlike shortest path algorithms or cycle detection, Kruskal's specifically builds a minimum spanning tree.
  3. Final Answer:

    To find the minimum spanning tree of a graph -> Option B
  4. Quick Check:

    Minimum Spanning Tree = Kruskal's Algorithm goal [OK]
Hint: Kruskal connects all nodes with least total edge weight [OK]
Common Mistakes:
  • Confusing MST with shortest path
  • Thinking it detects cycles only
  • Assuming it sorts vertices
2. Which Rust data structure is most suitable to efficiently implement the union-find (disjoint set) used in Kruskal's Algorithm?
easy
A. Vec<(usize, usize)>
B. HashMap
C. Vec<usize>
D. LinkedList<usize>

Solution

  1. Step 1: Identify union-find structure needs

    Union-find requires quick parent lookup and union operations, best done with an array-like structure where index is node and value is parent.
  2. Step 2: Match Rust data structures

    Vec<usize> is a simple array of parents, perfect for union-find. HashMap is slower, LinkedList is inefficient, Vec of tuples is not direct parent mapping.
  3. Final Answer:

    Vec<usize> -> Option C
  4. Quick Check:

    Union-find uses parent array = Vec<usize> [OK]
Hint: Use Vec for parent array in union-find [OK]
Common Mistakes:
  • Using HashMap instead of Vec for parent tracking
  • Choosing LinkedList which is slow for indexing
  • Using Vec of tuples which is unnecessary
3. What will be the output edges of the MST after running Kruskal's Algorithm on this graph? Edges with weights:

(0, 1, 4)
(0, 2, 3)
(1, 2, 1)
(1, 3, 2)
(2, 3, 4)
(3, 4, 2)
(4, 5, 6)
Assume vertices are 0 to 5.
medium
A. [(1, 2, 1), (1, 3, 2), (3, 4, 2), (0, 2, 3), (4, 5, 6)]
B. [(1, 2, 1), (1, 3, 2), (3, 4, 2), (0, 1, 4), (4, 5, 6)]
C. [(0, 2, 3), (1, 3, 2), (3, 4, 2), (4, 5, 6), (0, 1, 4)]
D. [(1, 2, 1), (0, 2, 3), (3, 4, 2), (4, 5, 6), (0, 1, 4)]

Solution

  1. Step 1: Sort edges by weight

    Sorted edges: (1,2,1), (1,3,2), (3,4,2), (0,2,3), (0,1,4), (2,3,4), (4,5,6)
  2. Step 2: Pick edges without cycles

    Pick (1,2,1), (1,3,2), (3,4,2), (0,2,3) connects 0,1,2,3,4 without cycle. Then (4,5,6) connects 5. Skip (0,1,4) and (2,3,4) as they form cycles.
  3. Final Answer:

    [(1, 2, 1), (1, 3, 2), (3, 4, 2), (0, 2, 3), (4, 5, 6)] -> Option A
  4. Quick Check:

    Edges chosen by increasing weight without cycles = [(1, 2, 1), (1, 3, 2), (3, 4, 2), (0, 2, 3), (4, 5, 6)] [OK]
Hint: Sort edges by weight, pick smallest without cycle [OK]
Common Mistakes:
  • Including edges that form cycles
  • Not sorting edges by weight
  • Skipping necessary edges to connect all nodes
4. Identify the bug in this Rust snippet implementing Kruskal's union-find 'find' function:

fn find(parent: &mut Vec<usize>, x: usize) -> usize {
    if parent[x] != x {
        parent[x] = find(parent, parent[x]);
    }
    x
}
medium
A. Missing return of updated parent[x] after recursion
B. Should not use mutable reference for parent
C. Incorrect base condition for recursion
D. Function should return bool instead of usize

Solution

  1. Step 1: Analyze the recursive find function

    The function updates parent[x] recursively but always returns x, ignoring updated parent[x].
  2. Step 2: Correct return statement

    It should return parent[x] after recursion to propagate the root parent upwards.
  3. Final Answer:

    Missing return of updated parent[x] after recursion -> Option A
  4. Quick Check:

    Return updated parent[x] in find function [OK]
Hint: Return recursive find result, not original x [OK]
Common Mistakes:
  • Returning x instead of parent[x]
  • Not using mutable reference for path compression
  • Changing return type incorrectly
5. Given a graph with edges:

(0, 1, 10), (0, 2, 6), (0, 3, 5), (1, 3, 15), (2, 3, 4)
If you run Kruskal's Algorithm but mistakenly sort edges in descending order by weight, what will be the total weight of the resulting spanning tree?
hard
A. 29
B. 25
C. Incorrect MST formed, total weight undefined
D. 31

Solution

  1. Step 1: Sort edges descending by weight

    Edges sorted descending: (1,3,15), (0,1,10), (0,2,6), (0,3,5), (2,3,4)
  2. Step 2: Pick edges without cycles in this order

    Pick (1,3,15), then (0,1,10) connects 0,1,3. Next (0,2,6) connects 2. Total edges: 3 edges connecting all 4 nodes.
  3. Step 3: Calculate total weight

    Sum = 15 + 10 + 6 = 31. But (0,3,5) and (2,3,4) are skipped to avoid cycles.
  4. Step 4: Check if cycle avoided correctly

    Actually, (0,3,5) connects 0 and 3 which are already connected, so skipped. (2,3,4) connects 2 and 3, but 2 is connected to 0, and 3 is connected to 1, so adding (2,3,4) creates cycle, skipped.
  5. Final Answer:

    31 -> Option D
  6. Quick Check:

    Descending sort picks heavy edges first, total weight = 31 [OK]
Hint: Descending sort picks heavy edges, MST weight increases [OK]
Common Mistakes:
  • Assuming MST weight stays minimal with descending sort
  • Adding edges that create cycles
  • Confusing total weight calculation
Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard