Adjacency Matrix Representation in DSA Rust - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a 3x3 adjacency matrix initialized with zeros.

DSA Rust

let mut matrix = vec![vec![[1]; 3]; 3];

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

A0

Bfalse

CNone

D1

Attempts:

3 left

💡 Hint

Common Mistakes

Using 1 instead of 0 initializes all edges as present.

Using None causes a type mismatch error.

The adjacency matrix is initialized with zeros to represent no edges between nodes.

2fill in blank

medium

Complete the code to set an edge from node 0 to node 2 in the adjacency matrix.

DSA Rust

matrix[0][[1]] = 1;

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

A3

B1

C0

D2

Attempts:

3 left

💡 Hint

Common Mistakes

Using index 3 causes an out-of-bounds error.

Using index 1 sets edge to wrong node.

Setting matrix[0][2] = 1 marks an edge from node 0 to node 2.

3fill in blank

hard

Fix the error in the code to correctly check if there is an edge from node 1 to node 0.

DSA Rust

if matrix[[1]][0] == 1 {
    println!("Edge exists");
}

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

A2

B0

C1

D3

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 as source index checks wrong edge.

Using index 3 causes out-of-bounds error.

To check edge from node 1 to node 0, use matrix[1][0].

4fill in blank

hard

Fill both blanks to iterate over all edges and print them if they exist.

DSA Rust

for i in 0..[1] {
    for j in 0..[2] {
        if matrix[i][j] == 1 {
            println!("Edge from {} to {}", i, j);
        }
    }
}

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

A3

Bmatrix.len()

Cmatrix[0].len()

D4

Attempts:

3 left

💡 Hint

Common Mistakes

Using fixed numbers limits matrix size.

Mixing rows and columns causes index errors.

Use matrix.len() for rows and matrix[0].len() for columns to cover all nodes.

5fill in blank

hard

Fill all three blanks to create a function that returns true if there is an edge from src to dst.

DSA Rust

fn has_edge(matrix: &Vec<Vec<i32>>, src: usize, dst: usize) -> bool {
    if matrix[[1]][[2]] == [3] {
        true
    } else {
        false
    }
}

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

Asrc

Bdst

C1

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping src and dst indices.

Checking for 0 instead of 1.

Check matrix[src][dst] == 1 to confirm edge presence.

Practice

1. What does an adjacency matrix represent in graph theory?

easy

A. A list of nodes in the graph

B. A 2D array showing edges between nodes

C. A sequence of visited nodes

D. A stack used for graph traversal

Solution

1. Step 1: Understand adjacency matrix concept

   An adjacency matrix is a 2D array where rows and columns represent nodes.

2. Step 2: Identify what the matrix stores

   Each cell shows if an edge exists between two nodes (1 for edge, 0 for no edge).

3. Final Answer:

   A 2D array showing edges between nodes -> Option B

4. Quick Check:

   Adjacency matrix = 2D edge array [OK]

Hint: Adjacency matrix is always a 2D grid of edges [OK]

Common Mistakes:

• Confusing adjacency matrix with adjacency list
• Thinking it stores node values instead of edges
• Mixing it with traversal order

2. Which Rust code snippet correctly declares a 3x3 adjacency matrix using Vec initialized with zeros?

easy

A. let matrix = vec![vec![0; 3]; 3];

B. let matrix = [0; 3][0; 3];

C. let matrix = [[0; 3]; 3];

D. let matrix = [[0, 0, 0], [0, 0, 0]];

Solution

1. Step 1: Understand Rust 2D vector initialization

   Rust uses Vec for dynamic 2D arrays; vec![vec![0; 3]; 3] creates 3 rows of 3 zeros.

2. Step 2: Check each option for correctness

   A: [[0; 3]; 3] creates fixed-size array [[i32;3]; 3], not Vec. B: [0; 3][0; 3] is invalid syntax. D: [[0, 0, 0], [0, 0, 0]] has only 2 rows.

3. Final Answer:

   let matrix = vec![vec![0; 3]; 3]; -> Option A

4. Quick Check:

   vec![vec![0; 3]; 3] creates 3x3 zero matrix [OK]

Hint: Use vec![vec![0; size]; size] for 2D matrix in Rust [OK]

Common Mistakes:

• Using invalid syntax for 2D arrays
• Confusing fixed arrays with vectors
• Incorrect row or column count

3. Given the following Rust code, what is the printed adjacency matrix?

let mut matrix = vec![vec![0; 3]; 3];
matrix[0][1] = 1;
matrix[1][2] = 1;
for row in &matrix {
    println!("{:?}", row);
}

medium

A. [1, 0, 0]\n[0, 1, 0]\n[0, 0, 1]

B. [0, 0, 1]\n[1, 0, 0]\n[0, 1, 0]

C. [0, 1, 0]\n[0, 0, 1]\n[0, 0, 0]

D. [0, 1, 1]\n[0, 0, 1]\n[1, 0, 0]

Solution

1. Step 1: Initialize 3x3 zero matrix

   matrix starts as [[0,0,0],[0,0,0],[0,0,0]].

2. Step 2: Update edges as per code

   matrix[0][1] = 1 sets edge from node 0 to 1; matrix[1][2] = 1 sets edge from node 1 to 2.

3. Step 3: Print matrix rows

   Rows print as [0,1,0], [0,0,1], [0,0,0].

4. Final Answer:

   [0, 1, 0]\n[0, 0, 1]\n[0, 0, 0] -> Option C

5. Quick Check:

   Edges at (0,1) and (1,2) = 1 [OK]

Hint: Track each assignment to matrix cells carefully [OK]

Common Mistakes:

• Mixing row and column indices
• Assuming symmetric edges in directed graph
• Printing matrix incorrectly

4. Identify the error in this Rust code for creating an adjacency matrix:

let mut matrix = vec![vec![0; 3]; 3];
matrix[3][0] = 1;

medium

A. Index out of bounds error

B. Type mismatch error

C. Syntax error in vector initialization

D. No error, code runs fine

Solution

1. Step 1: Check vector size and indices

   matrix is 3x3 with valid indices 0,1,2 for rows and columns.

2. Step 2: Analyze matrix[3][0] access

   Index 3 is out of bounds for rows (max index 2), causing runtime panic.

3. Final Answer:

   Index out of bounds error -> Option A

4. Quick Check:

   Accessing index 3 in size 3 vector causes error [OK]

Hint: Check indices are within 0 to size-1 [OK]

Common Mistakes:

• Using invalid indices beyond matrix size
• Confusing compile-time and runtime errors
• Ignoring Rust's panic on out-of-bounds

5. You have a directed graph with 4 nodes. Using an adjacency matrix in Rust, how would you represent edges from node 0 to 1 and 2, and from node 3 to 0? Which matrix correctly shows this?

hard

A. [[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]

B. [[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 0, 0]]

C. [[0, 0, 0, 1], [1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0]]

D. [[0, 1, 1, 0], [0, 0, 0, 0], [0, 0, 0, 0], [1, 0, 0, 0]]

Solution

1. Step 1: Understand node indexing and edges

   Nodes are 0 to 3. Edges: 0->1, 0->2, 3->0.

2. Step 2: Map edges to adjacency matrix

   Row 0 has 1s at columns 1 and 2. Row 3 has 1 at column 0. Others are 0.

3. Step 3: Verify options

   [[0, 1, 1, 0], [0, 0, 0, 0], [0, 0, 0, 0], [1, 0, 0, 0]] matches this exactly. Others have wrong edges or self loops.

4. Final Answer:

   [[0, 1, 1, 0], [0, 0, 0, 0], [0, 0, 0, 0], [1, 0, 0, 0]] -> Option D

5. Quick Check:

   Edges 0->1,0->2 and 3->0 set correctly [OK]

Hint: Rows = from-node, columns = to-node edges [OK]

Common Mistakes:

• Mixing up row and column meaning
• Adding edges not specified
• Confusing directed with undirected edges