Week 7: Adjacency Matrices

BSCS1001 — IIT Madras BS Degree Prerequisite: Topic 13 (Graphs Introduction), Topic 11 (Dictionaries) Cross-links: BSCS2002-PDSA (Week 7 — Graph Representations)

1. Motivation: Why Matrices?

2. What is a Matrix?

Matrix Notation

sql
M[i][j] = 1  →  Edge from vertex i to vertex j
M[i][j] = 0  →  No edge from i to j

Visual Example

3. Creating Matrices with Nested Dictionaries

CreateMatrix Procedure

pseudo
Procedure CreateMatrix(rows, cols)
    mat = {}
    i = 0
    while (i < rows) {
        mat[i] = {}
        j = 0
        while (j < cols) {
            mat[i][j] = 0
            j = j + 1
        }
        i = i + 1
    }
    return(mat)
End CreateMatrix

Example: Creating a 3×3 Matrix

sql
mymatrix = CreateMatrix(3, 3)
mymatrix[0][1] = 1    // Set edge from 0 to 1
mymatrix[1][2] = 1    // Set edge from 1 to 2
mymatrix[0][2] = 1    // Set edge from 0 to 2

pseudo
    0  1  2
0  [0, 1, 1]
1  [0, 0, 1]
2  [0, 0, 0]

Mapping Names to Indices

pseudo
// Collect unique names
allStudents = []
while (Pile 1 has more cards) {
    Pick X
    allStudents = allStudents ++ [X.Name]
}
// Create name → index mapping
nameToIdx = {}
i = 0
foreach name in allStudents {
    nameToIdx[name] = i
    i = i + 1
}
// Create graph using indices
n = length(allStudents)
graph = CreateMatrix(n, n)
graph[nameToIdx["Alice"]][nameToIdx["Bob"]] = 1

4. Row-Wise and Column-Wise Processing

Iterating Through a Matrix

pseudo
// Row-wise (standard)
foreach r in rows(mymatrix) {
    foreach c in columns(mymatrix) {
        // Process mymatrix[r][c]
    }
}
// Column-wise
foreach c in columns(mymatrix) {
    foreach r in rows(mymatrix) {
        // Process mymatrix[r][c]
    }
}

Row Sum = Outgoing Degree

sql
outDegree = {}
foreach i in rows(graph) {
    count = 0
    foreach j in columns(graph) {
        if (graph[i][j] == 1) {
            count = count + 1
        }
    }
    outDegree[i] = count    // How many edges FROM i
}

Column Sum = Incoming Degree

pseudo
inDegree = {}
foreach j in columns(graph) {
    count = 0
    foreach i in rows(graph) {
        if (graph[i][j] == 1) {
            count = count + 1
        }
    }
    inDegree[j] = count    // How many edges TO j
}

5. Adjacency Matrix Properties

Key Properties

Undirected vs Directed

pseudo
    A B C
A  [0,1,1]    // A-B, A-C
B  [1,0,1]    // B-A, B-C
C  [1,1,0]    // C-A, C-B
// Symmetric!

sql
    A B C
A  [0,1,1]    // A→B, A→C
B  [0,0,1]    // B→C (but not C→B)
C  [0,0,0]    // No outgoing from C
// Not symmetric

6. Similarity Graph

Problem

Algorithm

pseudo
Procedure CreateSimilarityGraph(marks1, marks2, marks3)
    n = length(keys(marks1))
    similarityGraph = CreateMatrix(n, n)
    foreach i in keys(marks1) {
        foreach j in keys(marks1) {
            diff1 = abs(marks1[i] - marks1[j])
            diff2 = abs(marks2[i] - marks2[j])
            diff3 = abs(marks3[i] - marks3[j])
            if (diff1 ≤ 10 AND diff2 ≤ 10 AND diff3 ≤ 10) {
                similarityGraph[i][j] = 1
            }
        }
    }
    return(similarityGraph)
End CreateSimilarityGraph

Properties

• Symmetric: If i is similar to j, then j is similar to i
• Reflexive: (Optionally) i is similar to itself
• Cliques: Groups where all are similar form cliques

7. Mentoring Graph Revisited

With Matrix Representation

pseudo
Procedure CreateMentorGraph(marks)
    n = length(keys(marks))
    mentorGraph = CreateMatrix(n, n)
    foreach i in keys(marks) {
        foreach j in keys(marks) {
            diff = marks[i] - marks[j]
            if (10 ≤ diff AND diff ≤ 20) {
                mentorGraph[i][j] = 1    // i can mentor j
            }
        }
    }
    return(mentorGraph)
End CreateMentorGraph

Finding Mutual Mentoring Pairs

pseudo
// i and j can be study partners if:
// i mentors j in Maths AND j mentors i in Physics
studyPairs = []
foreach i in rows(mathMentor) {
    foreach j in columns(mathMentor) {
        if (mathMentor[i][j] == 1 AND phyMentor[j][i] == 1) {
            studyPairs = studyPairs ++ [(i, j)]
        }
    }
}

8. Matrix Operations

Copy a Matrix

pseudo
Procedure CopyMatrix(mat)
    n = length(keys(mat))
    newMat = CreateMatrix(n, n)
    foreach i in rows(mat) {
        foreach j in columns(mat) {
            newMat[i][j] = mat[i][j]
        }
    }
    return(newMat)
End CopyMatrix

Transpose (Swap Rows and Columns)

pseudo
Procedure Transpose(mat)
    n = length(keys(mat))
    result = CreateMatrix(n, n)
    foreach i in rows(mat) {
        foreach j in columns(mat) {
            result[j][i] = mat[i][j]
        }
    }
    return(result)
End Transpose

Add Two Matrices

pseudo
Procedure AddMatrices(A, B)
    n = length(keys(A))
    result = CreateMatrix(n, n)
    foreach i in rows(A) {
        foreach j in columns(A) {
            // Boolean OR for adjacency
            result[i][j] = A[i][j] OR B[i][j]
        }
    }
    return(result)
End AddMatrices

9. Comparison: Matrix vs List Representations

Which to Use?

1. Simple to create and access
2. The graphs we work with are often dense (many edges)
3. Matrix operations (transitive closure, shortest paths) are straightforward

10. Practice Questions

Basic Questions

Show Answer

An adjacency matrix is an N×N table where M[i][j] = 1 if there is an edge from vertex i to vertex j, and 0 otherwise. It represents a graph's connectivity. Q2. How big is the adjacency matrix for a graph with 6 vertices? Show Answer

6 × 6 = 36 entries. The diagonal is usually 0. Q3. What does a symmetric matrix indicate about a graph? Show Answer

A symmetric matrix (M[i][j] = M[j][i]) indicates an undirected graph — if there's an edge from i to j, there's also an edge from j to i. Q4. How do you find the number of outgoing edges from vertex i? Show Answer

Sum row i: count = 0; foreach j in columns(graph) { if graph[i][j] == 1 → count++ }

Intermediate Questions

Show Answer

pseudo
mat = CreateMatrix(4, 4)
foreach i in rows(mat) {
    foreach j in columns(mat) {
        if (i ≠ j) {
            mat[i][j] = 1
        }
    }
}

Show Answer

• Row-wise: Outer loop over rows, inner loop over columns. Processes each vertex's outgoing edges.
• Column-wise: Outer loop over columns, inner loop over rows. Processes each vertex's incoming edges.

For undirected graphs, both give the same result. For directed graphs, they differ. Q7. In the similarity graph, why is the condition checked for ALL three subjects? Show Answer

Students are similar only if their marks differ by at most 10 in every subject. If we only checked one or two subjects, we might incorrectly label students as similar when they have very different marks in the unchecked subject. Q8. Convert this matrix into a list of edges:

pseudo
    A B C
A  [0,1,1]
B  [0,0,1]
C  [0,0,0]

Show Answer

Edges: (A→B), (A→C), (B→C) = 3 directed edges.

📚 Cross-References

Next Topic: 14 — Graph Algorithms — Routes & Paths

Quiz Tip: Understand how to read and construct adjacency matrices. Know the difference between directed and undirected! Join Discord PreviousGraphs & Adjacency MatricesNextGraph Algorithms — Routes & Paths