Adjacency Matrix Representation in DSA Rust - Time & Space Complexity

Time Complexity: Adjacency Matrix Representation

O(n^2)

Understanding Time Complexity

We want to understand how the time to work with an adjacency matrix changes as the graph grows.

Specifically, how long it takes to check connections or build the matrix as the number of nodes increases.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

fn create_adjacency_matrix(n: usize, edges: &[(usize, usize)]) -> Vec> {
    let mut matrix = vec![vec![0; n]; n];
    for &(u, v) in edges {
        matrix[u][v] = 1;
        matrix[v][u] = 1; // for undirected graph
    }
    matrix
}
    

This code builds an adjacency matrix for an undirected graph with n nodes and given edges.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping over all edges to update the matrix.
• How many times: Once for each edge in the list.

How Execution Grows With Input

As the number of nodes and edges grow, the time to build the matrix grows mainly with the number of edges.

Input Size (n)	Approx. Operations (edges)
10 nodes, 15 edges	15 updates
100 nodes, 500 edges	500 updates
1000 nodes, 2000 edges	2000 updates

Pattern observation: The time grows roughly with the number of edges, not just nodes.

Final Time Complexity

Time Complexity: O(n^2)

This means the time to build or check the matrix grows with the square of the number of nodes, because the matrix size is n by n.

Common Mistake

[X] Wrong: "Building the adjacency matrix only takes time proportional to the number of edges."

[OK] Correct: While updating edges is proportional to edges, the matrix itself is size n by n, so operations like checking all connections or initializing the matrix take time proportional to n squared.

Interview Connect

Understanding adjacency matrix time complexity helps you choose the right graph representation and explain trade-offs clearly in interviews.

Self-Check

"What if we used an adjacency list instead of a matrix? How would the time complexity change?"

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