Adjacency Matrix Representation in DSA Java - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to declare a 2D adjacency matrix for 4 vertices.

DSA Java

int[][] adjacencyMatrix = new int[[1]][[1]];

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

A5

B6

C3

D4

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong size for the matrix like 5 or 3.

Confusing the number of vertices with edges.

The adjacency matrix for 4 vertices is a 4x4 2D array.

2fill in blank

medium

Complete the code to add an edge from vertex 1 to vertex 3 in the adjacency matrix.

DSA Java

adjacencyMatrix[[1]][3] = 1;

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

A1

B0

C2

D3

Attempts:

3 left

💡 Hint

Common Mistakes

Using 0 instead of 1 for vertex 1.

Using 3 instead of 1 for the row index.

Vertices are zero-indexed, so vertex 1 corresponds to index 1.

3fill in blank

hard

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

DSA Java

if (adjacencyMatrix[[1]][0] == 1) {
    System.out.println("Edge exists");
}

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

A1

B2

C0

D3

Attempts:

3 left

💡 Hint

Common Mistakes

Using 1 or 0 instead of 2 for the source vertex index.

Confusing row and column indices.

To check edge from vertex 2 to 0, use row index 2 and column 0.

4fill in blank

hard

Fill both blanks to correctly initialize an adjacency matrix for 5 vertices and set no edges initially.

DSA Java

int[][] adjacencyMatrix = new int[[1]][[2]];

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

A5

B4

C6

D3

Attempts:

3 left

💡 Hint

Common Mistakes

Using different sizes for rows and columns.

Using sizes less or more than the number of vertices.

The adjacency matrix for 5 vertices is a 5x5 matrix initialized with zeros.

5fill in blank

hard

Fill all three blanks to print all edges from vertex 0 in the adjacency matrix.

DSA Java

for (int [1] = 0; [1] < adjacencyMatrix[0].length; [1]++) {
    if (adjacencyMatrix[0][[2]] == [3]) {
        System.out.println("Edge from 0 to " + [2]);
    }
}

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

Ai

Bj

C1

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using different variables for loop and index.

Checking for 0 instead of 1 to find edges.

Use 'i' as loop variable, check adjacencyMatrix[0][i] == 1 to find edges.

Practice

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

easy

A. A 2D array showing edges between nodes

B. A list of nodes in the graph

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 A

4. Quick Check:

   Adjacency matrix = 2D array of edges [OK]

Hint: Adjacency matrix is always a 2D array showing connections [OK]

Common Mistakes:

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

2. Which of the following is the correct way to declare an adjacency matrix for a graph with 4 nodes in Java?

easy

A. int[] matrix = new int[4][4];

B. int matrix = new int[4];

C. int[][] matrix = new int[4][4];

D. int[][] matrix = new int[4];

Solution

1. Step 1: Recall Java 2D array declaration syntax

   In Java, a 2D array is declared as type[][] name = new type[rows][columns];

2. Step 2: Match with graph nodes count

   For 4 nodes, we need a 4x4 matrix, so new int[4][4] is correct.

3. Final Answer:

   int[][] matrix = new int[4][4]; -> Option C

4. Quick Check:

   2D array for 4 nodes = new int[4][4] [OK]

Hint: 2D array syntax: type[][] name = new type[size][size]; [OK]

Common Mistakes:

• Using single brackets for 2D array
• Declaring 1D array instead of 2D
• Incorrect array initialization syntax

3. Given the following adjacency matrix for a graph with 3 nodes:

int[][] matrix = {
  {0, 1, 0},
  {1, 0, 1},
  {0, 1, 0}
};
What is the output of the code snippet?
for (int i = 0; i < 3; i++) {
  for (int j = 0; j < 3; j++) {
    if (matrix[i][j] == 1) {
      System.out.print(i + "->" + j + " ");
    }
  }
}

medium

A. 0->2 2->0

B. 0->0 1->1 2->2

C. 1->0 2->1

D. 0->1 1->0 1->2 2->1

Solution

1. Step 1: Analyze the matrix values

   matrix[0][1] = 1, matrix[1][0] = 1, matrix[1][2] = 1, matrix[2][1] = 1; others are 0.

2. Step 2: Trace the nested loops and print statements

   For each 1, print "i->j ": 0->1, 1->0, 1->2, 2->1.

3. Final Answer:

   0->1 1->0 1->2 2->1 -> Option D

4. Quick Check:

   Edges printed where matrix[i][j] = 1 [OK]

Hint: Print edges where matrix cell is 1 [OK]

Common Mistakes:

• Printing zeros as edges
• Mixing i and j indices
• Skipping symmetric edges

4. Identify the error in the following code snippet that tries to create an adjacency matrix for 3 nodes:

int[][] matrix = new int[3];
matrix[0][1] = 1;

medium

A. Index out of bounds error at matrix[0][1]

B. 2D array declared incorrectly with single dimension

C. Matrix values cannot be assigned directly

D. Missing import statement for arrays

Solution

1. Step 1: Check array declaration syntax

   int[][] matrix = new int[3]; declares a 1D array of int arrays but does not initialize inner arrays.

2. Step 2: Understand why matrix[0][1] causes error

   Inner arrays are null, so accessing matrix[0][1] causes NullPointerException or compile error.

3. Final Answer:

   2D array declared incorrectly with single dimension -> Option B

4. Quick Check:

   2D array needs both dimensions declared [OK]

Hint: Declare both dimensions for 2D arrays: new int[size][size] [OK]

Common Mistakes:

• Declaring only one dimension for 2D array
• Not initializing inner arrays
• Confusing array types

5. You have a directed graph with 4 nodes and edges: 0->1, 0->2, 1->2, 2->3. Which adjacency matrix correctly represents this graph?

hard

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

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

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

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

Solution

1. Step 1: Map edges to matrix positions

   Edges: 0->1 means matrix[0][1]=1, 0->2 means matrix[0][2]=1, 1->2 means matrix[1][2]=1, 2->3 means matrix[2][3]=1.

2. Step 2: Check each option for these values

   [[0,1,1,0],[0,0,1,0],[0,0,0,1],[0,0,0,0]] matches exactly these edges with 1s in correct places and 0s elsewhere.

3. Final Answer:

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

4. Quick Check:

   Edges mapped as 1s in matrix [OK]

Hint: Mark 1 for each edge from row to column [OK]

Common Mistakes:

• Confusing directed edges with undirected
• Placing 1s symmetrically for directed graph
• Missing edges in matrix