Week 10: Graph Theory, Representations, BFS & DFS

4108 words

21 min read

2026-09-12T00:00:00.000Z

Visual companion

Maths

Sets and relations

Maths Week 1: the start of the relation ladder

Open gallery Related surface

View

Revision summary

What this note is really saying

Short form

Vertices, edges, degrees, handshaking lemma, adjacency matrices/lists, BFS, DFS, trees, DAGs, and topological sorting. # Mathematics I — Week 10: Graph Theory, Representations, BFS & DFS IITM’s Week 10 moves into **graph theory: representation of graphs, breadth-first search, depth-first search, applications of BFS/...

Visual strip

Relevant recall pieces for this note

Open gallery

Maths

Sets and relations

Maths Week 1: the start of the relation ladder

Maths

Limit and continuity

Maths Week 3: the spectrum from close to exact

Maths

Derivative chooser

Maths Week 5: rule selection before calculation

Mathematics I — Week 10: Graph Theory, Representations, BFS & DFS

IITM’s Week 10 moves into graph theory: representation of graphs, breadth-first search, depth-first search, applications of BFS/DFS, and directed acyclic graphs.

TL;DR

A graph models objects and relationships:

G=(V,E)

where:

$V$ = vertices/nodes
$E$ = edges/connections

The highest-value Week 10 ideas are:

graph vocabulary
undirected vs directed graphs
adjacency representations
degree / in-degree / out-degree
paths and connectivity
BFS
DFS
connected components
cycles
DAGs
why BFS and DFS have different behavior

1. What is a graph?

A graph is usually written:

\boxed{ G=(V,E) }

where:

$V$ is a set of vertices
$E$ is a set of edges

Example:

V=\{A,B,C,D\}

and:

E=\{\{A,B\},\{B,C\},\{C,D\}\}.

This describes:


text
A — B — C — D

2. Why graphs matter

Graphs can model:

social networks
roads
airline routes
web pages and hyperlinks
computer networks
dependencies
family trees
recommendation systems
state transitions
knowledge graphs

The abstraction is:

entities + relationships

3. Undirected graph

In an undirected graph, an edge has no direction.

If:

\{A,B\}\in E,

then

A

is connected to

B

and

B

is connected to

A

Graphically:


text
A — B

4. Directed graph

A directed graph or digraph uses directed edges:

(A,B)

meaning:

A\to B.

This does not automatically imply:

B\to A.

Example:


text
A → B → C

Directed graphs are useful for:

follower relationships
prerequisites
hyperlinks
workflows
dependency graphs

5. Vertex / node

A vertex is one object in the graph.

Plural:

vertices
nodes

These terms are often used interchangeably.

6. Edge

An edge represents a relationship between vertices.

Undirected:

\{u,v\}

Directed:

(u,v)

or:

u\to v.

7. Adjacent vertices

Two vertices are adjacent if an edge connects them.

If:

A-B,

then:

A

and:

B

are adjacent.

8. Neighbors

The neighbors of a vertex are all vertices directly connected to it.

For:


text
A — B — C
    |
    D

neighbors of

B

are:

\{A,C,D\}.

9. Degree of a vertex

In an undirected graph, the degree of vertex

v

is the number of incident edges.

Notation:

\deg(v)

Example:


text
A — B — C
    |
    D

Then:

\deg(B)=3.

And:

\deg(A)=1.

10. Handshaking lemma

For an undirected graph:

\boxed{ \sum_{v\in V}\deg(v)=2|E| }

Why?

Every edge contributes:

1

to the degree of each of its two endpoints.

So each edge gets counted twice.

11. Consequence: odd-degree vertices

The number of vertices with odd degree is always even.

This follows from the handshaking lemma.

A surprisingly useful graph-theory fact.

12. In-degree and out-degree

For directed graphs:

In-degree

Number of edges entering a vertex.

\deg^-(v)

Out-degree

Number of edges leaving a vertex.

\deg^+(v)

Example:


text
A → B ← C
    ↓
    D

For

B

\deg^-(B)=2

and:

\deg^+(B)=1.

13. Directed degree identity

For a directed graph:

\boxed{ \sum_v \deg^-(v)=|E| }

and:

\boxed{ \sum_v \deg^+(v)=|E| }

Each directed edge contributes once to total in-degree and once to total out-degree.

14. Walk

A walk is a sequence of vertices where consecutive vertices are connected.

Vertices and edges may repeat.

Example:

A\to B\to C\to B\to D.

This can be a valid walk even though

B

repeats.

15. Path

A path typically means a walk without repeated vertices.

Example:

A\to B\to C\to D.

Path length is usually the number of edges.

So:

A-B-C-D

has length:

3.

16. Cycle

A cycle starts and ends at the same vertex, without unnecessary repetition of internal vertices.

Example:


text
A — B
|   |
D — C

One cycle:

A\to B\to C\to D\to A.

17. Connected graph

An undirected graph is connected if every pair of vertices has a path between them.

Example:


text
A — B — C
    |
    D

Everything is reachable from everything else.

So the graph is connected.

18. Disconnected graph

Example:


text
A — B     C — D

There is no path from

A

C

So the graph is disconnected.

19. Connected components

A connected component is a maximal connected part of a graph.

For:


text
A — B     C — D — E     F

there are:

3

connected components:

\{A,B\}

\{C,D,E\}

\{F\}.

20. Complete graph

A complete graph has an edge between every pair of distinct vertices.

Notation:

K_n.

For

n

vertices, the number of edges is:

\boxed{ \binom n2=\frac{n(n-1)}2 }

21. Why?

Each edge corresponds to choosing:

2

vertices from

n

So:

|E|=\binom n2.

Example:

K_5

has:

\frac{5\cdot4}{2}=10

edges.

22. Graph representation problem

A graph is an abstract object.

A computer needs a concrete representation.

Two major representations:

adjacency matrix
adjacency list

23. Adjacency matrix

For

n

vertices, create an:

n\times n

matrix.

Let:

A_{ij}= \begin{cases} 1,&\text{if edge }i\to j\text{ exists}\\ 0,&\text{otherwise} \end{cases}

For undirected graphs, the matrix is symmetric.

24. Example

Graph:


text
A — B
|
C

Ordering:

A,B,C.

Adjacency matrix:

\begin{pmatrix} 0&1&1\\ 1&0&0\\ 1&0&0 \end{pmatrix}

25. Why diagonal entries are often zero

In a simple graph, there are no self-loops.

So:

A_{ii}=0.

If self-loops are allowed, diagonal entries may be nonzero.

26. Symmetry in undirected graphs

If:

A-B,

then:

A_{AB}=1

and:

A_{BA}=1.

Therefore:

\boxed{ A=A^T }

for simple undirected graphs.

27. Adjacency list

Instead of storing an entire matrix, store each vertex's neighbors.

Example:


text
A — B
|
C

Adjacency list:


text
A: B, C
B: A
C: A

28. Matrix vs list

Adjacency matrix

Space:

O(V^2)

Good for:

dense graphs
fast edge existence lookup

Adjacency list

Space:

O(V+E)

Good for:

sparse graphs
traversal algorithms

Most real-world sparse graphs favor adjacency lists.

29. Edge lookup complexity

With adjacency matrix:

Is there edge $(u,v)$ ?

Usually:

O(1).

With adjacency list:

depends on how neighbors are stored.

Potentially:

O(\deg(u)).

30. Graph traversal

Graph traversal means:

systematically visit vertices of a graph.

Two fundamental algorithms:

\boxed{\text{BFS}}

and:

\boxed{\text{DFS}}.

31. Breadth-First Search

BFS = Breadth-First Search.

Core idea:

Explore the graph layer by layer.

Starting from a source:

visit source
visit all neighbors
visit neighbors of those neighbors
continue outward

32. BFS mental picture

Suppose:


text
        A
      /   \
     B     C
    / \     \
   D   E     F

Starting BFS at:

A,

a typical traversal:

A,B,C,D,E,F.

It visits by distance layers:

0,1,2,\dots

33. BFS uses a queue

BFS is naturally implemented using a queue.

Queue behavior:

\boxed{\text{FIFO}}

First In, First Out.

Conceptually:


text
enqueue(start)

while queue not empty:
    v = dequeue()
    for each unvisited neighbor u:
        mark u visited
        enqueue(u)

34. Why marking visited matters

Graphs can contain cycles.

Without a visited set:


text
A — B
|   |
D — C

the algorithm could keep looping:

A\to B\to C\to D\to A\to\cdots

So each vertex should generally be marked visited.

35. BFS and shortest paths

One of BFS's most important properties:

In an unweighted graph, BFS finds shortest paths measured by number of edges.

Why?

Because it explores vertices in increasing distance from the source.

First:

0

edges away.

Then:

1

edge away.

Then:

2

edges away.

And so on.

36. Example

Graph:


text
A — B — D
|   |
C — E

Start:

A.

Distances:

d(A)=0

d(B)=1,\qquad d(C)=1

d(D)=2,\qquad d(E)=2.

BFS naturally discovers these layers.

37. BFS applications

Common applications:

shortest path in unweighted graph
finding connected components
network broadcasting
degree-of-separation problems
web crawling
bipartite testing
level-order exploration

38. Depth-First Search

DFS = Depth-First Search.

Core idea:

Go as deep as possible before backtracking.

From a vertex:

choose an unvisited neighbor
explore it
continue deeper
when stuck, backtrack

39. DFS mental picture

Using:


text
        A
      /   \
     B     C
    / \     \
   D   E     F

Possible DFS:

A,B,D,E,C,F.

Exact order depends on neighbor ordering.

The defining feature is depth-first behavior, not one fixed output sequence.

40. DFS uses a stack

DFS can be implemented using:

recursion
explicit stack

Stack behavior:

\boxed{\text{LIFO}}

Last In, First Out.

Recursive pseudocode:


text
DFS(v):
    mark v visited

    for each neighbor u of v:
        if u not visited:
            DFS(u)

41. Backtracking intuition

DFS explores:


text
A
↓
B
↓
D

D

has nowhere new to go, it returns:


text
D
↑
B

Then explores another branch.

That returning behavior is backtracking.

42. DFS applications

DFS is useful for:

connected components
detecting cycles
topological sorting
maze exploration
dependency analysis
path existence
structural graph analysis
strongly connected components in more advanced settings

43. BFS vs DFS

BFS	DFS
breadth first	depth first
queue	stack/recursion
explores levels	explores branches
shortest unweighted path	not generally shortest
useful for distance	useful for structure/backtracking

Neither is universally "better."

They solve different kinds of problems naturally.

44. BFS complexity

Using adjacency lists:

\boxed{ O(V+E) }

Why?

Each vertex is processed at most once.

Each edge is examined a constant number of times.

45. DFS complexity

Also:

\boxed{ O(V+E) }

with adjacency-list representation.

So asymptotically BFS and DFS often have the same traversal complexity.

Their behavior and applications differ.

46. Traversal on disconnected graphs

Starting BFS/DFS from one vertex only explores its connected component.

To visit the entire graph:


text
for each vertex v:
    if v unvisited:
        BFS(v)

or DFS.

Each new traversal discovers another component.

47. Counting connected components

Initialize:

count=0.

For every unvisited vertex:

increment count
run BFS/DFS from it

At the end:

count

equals number of connected components.

48. Cycle detection intuition

In an undirected graph during DFS:

If you encounter a visited neighbor that is not the current vertex's parent, you have found a cycle.

In directed graphs, cycle detection requires tracking traversal state more carefully.

49. Trees

A tree is an undirected graph that is:

connected
acyclic

A tree with:

n

vertices always has:

\boxed{n-1}

edges.

50. Equivalent tree characterizations

For a finite undirected graph, several statements are equivalent:

connected and acyclic
exactly one simple path between every pair of vertices
connected with $|V|-1$ edges
acyclic with $|V|-1$ edges

These relationships are highly useful.

51. Why trees matter here

BFS and DFS naturally generate search trees.

As you discover new vertices, you can remember which vertex discovered each one.

Those parent relationships form a tree.

52. BFS tree

A BFS tree rooted at source

s

organizes vertices by distance:


text
distance 0: s
distance 1: neighbors
distance 2: neighbors of neighbors
...

So it captures shortest unweighted distances.

53. DFS tree

A DFS tree captures the recursive exploration structure.

It is especially useful for reasoning about:

ancestry
backtracking
cycles
ordering

54. Directed Acyclic Graph

A DAG is a:

\boxed{\text{Directed Acyclic Graph}}

So it is:

directed
contains no directed cycle

Example:


text
A → B → D
 \      ↑
  → C ──

provided there is no route that returns to the starting node following arrow directions.

55. Why DAGs are important

DAGs model dependencies.

Examples:

Courses


text
Calculus I → Calculus II

Build systems


text
source → compile → package → deploy

Tasks


text
design → implement → test → release

Data pipelines


text
raw data → clean → transform → train

56. Directed cycle problem

Suppose:


text
A → B
↑   ↓
D ← C

Then:

A\to B\to C\to D\to A.

This is a directed cycle.

So the graph is not a DAG.

In a dependency system, this could mean:

A depends on B, B depends on C, ..., and something eventually depends back on A.

That is impossible to resolve sequentially.

57. Topological ordering intuition

A DAG can be arranged so that every directed edge points forward.

Example:


text
A → B
A → C
B → D
C → D

One topological ordering:

A,B,C,D.

Another:

A,C,B,D.

Topological order is generally not unique.

58. What topological order means

For every edge:

u\to v,

vertex

u

must appear before

v

This makes topological ordering ideal for dependency scheduling.

59. A directed graph has a topological ordering iff

For a finite directed graph:

\boxed{ \text{topological ordering exists} \iff \text{graph is a DAG} }

This is a fundamental relationship.

60. BFS-style topological sorting intuition

One approach repeatedly chooses vertices with:

\text{in-degree}=0.

Why?

Such a vertex has no unresolved prerequisites.

Process it, remove its outgoing edges, and repeat.

This is commonly known as Kahn's algorithm.

Even if not required by name, understand the mechanism.

61. DFS-style topological sorting intuition

DFS can also construct a topological order.

Rough idea:

place a vertex after all vertices reachable from it have been processed.

Then reverse finishing order.

This is another example of DFS being useful for structural ordering.

62. Graph traversal ordering is not unique

Suppose

A

has neighbors:

B,C,D.

If the representation lists:

B,C,D,

one BFS/DFS order results.

If it lists:

D,B,C,

another may result.

Therefore, unless neighbor ordering is specified:

multiple traversal sequences may be valid.

This is a common MCQ trap.

63. Path existence

To determine whether there is a path from:

s

to:

t,

run BFS or DFS from

s

If:

t

is visited, a path exists.

If traversal completes without visiting

t

, no path exists in that reachable component.

64. Recovering a path

During BFS/DFS, store:

parent[v].

When

v

is first discovered from

u

parent[v]=u.

Then to recover path from source to target:

t \to parent[t] \to parent[parent[t]] \to\cdots

until source.

Reverse that sequence.

65. BFS shortest-path example

Suppose:


text
A — B — D
|   |
C — E — F

From

A

, BFS might assign:

parent[B]=A

parent[C]=A

parent[D]=B

parent[E]=B

parent[F]=E.

Then shortest path to

F

A\to B\to E\to F.

Length:

3.

66. Graph as relation — Week 1 connection

Recall Week 1:

A relation:

R\subseteq A\times A.

A directed graph on vertex set

V

can be viewed as a relation:

E\subseteq V\times V.

So relation theory and graph theory are closely connected.

An edge:

(u,v)

simply means:

uRv.

67. Adjacency matrix as relation matrix

For a relation:

R\subseteq V\times V,

the adjacency matrix records:

A_{ij}=1

exactly when:

v_iRv_j.

So Week 10 is partly a computational representation of Week 1 relations.

68. Symmetric relation ↔ undirected-style adjacency

If a directed relation is symmetric:

uRv\Rightarrow vRu,

then its adjacency matrix is symmetric.

This mirrors an undirected graph.

Nice connection:

\boxed{ \text{symmetric relation} \leftrightarrow \text{symmetric adjacency matrix} }

69. Reflexivity ↔ self-loops

Recall:

vRv

for every

v

means reflexive.

Graphically, every vertex would have a self-loop:


text
 ↺
 A

So relation properties have natural graph interpretations.

70. Transitivity ↔ shortcut edges

If:

u\to v

and:

v\to w,

transitivity requires:

u\to w.

So the Week 1 mental model:

every two-step relation requires a shortcut

is literally graph language.

71. Complexity intuition

For graph algorithms, input size is not just:

V.

There may also be many edges:

E.

So traversal complexity:

O(V+E)

means work grows roughly with the amount of graph data that actually exists.

This is more informative than saying simply:

O(V^2).

for sparse graphs.

72. Sparse vs dense graphs

A sparse graph has relatively few edges.

Typically:

E\ll V^2.

A dense graph has many possible edges present.

This distinction affects which representation is sensible.

Sparse

Adjacency list often better.

Dense

Adjacency matrix may be convenient.

73. Maximum undirected edges

For a simple graph with:

n

vertices:

\boxed{ |E|_{\max} = \frac{n(n-1)}2 }

because each pair can have at most one edge.

74. Maximum directed edges

For a simple directed graph without self-loops:

each ordered pair of distinct vertices can be an edge.

So:

\boxed{ |E|_{\max}=n(n-1) }

because direction distinguishes:

u\to v

from:

v\to u.

Common mistake: BFS always gives unique order

No.

BFS guarantees increasing distance layers, but the ordering within a layer may depend on adjacency ordering.

Common mistake: DFS finds shortest paths

Not generally.

DFS may go down a long branch before discovering a much shorter route.

For shortest paths in an unweighted graph, think:

\boxed{\text{BFS}}

Common mistake: graph cycle means repeated vertex in traversal

A traversal can encounter a repeated vertex conceptually because the graph has multiple incoming routes, but visited-state handling prevents processing it repeatedly.

Cycle is a structural property of the graph, not simply "I saw something twice in my notes."

Common mistake: DAG means no undirected cycle

A DAG specifically means:

no directed cycles.

The underlying undirected structure may contain an undirected cycle while the edge directions prevent a directed cycle.

Example:


text
A → B
↓   ↓
C → D

Underlying undirected edges form a square-like structure, but there may be no directed route returning to its start.

Common mistake: degree in directed graph

Do not use a single ambiguous degree if the question distinguishes direction.

Track:

\deg^-(v)

and:

\deg^+(v).

Common mistake: path length

Path:

A\to B\to C\to D

contains:

$4$ vertices
$3$ edges

Path length is usually:

\boxed{3}

not

4

81. BFS pseudocode

A clean conceptual version:


text
BFS(G, s):
    mark s visited
    enqueue s

    while queue not empty:
        v = dequeue

        for each neighbor u of v:
            if u not visited:
                mark u visited
                parent[u] = v
                enqueue u

Key structure:

\boxed{\text{queue}}

82. DFS pseudocode

Recursive version:


text
DFS(G, v):
    mark v visited

    for each neighbor u of v:
        if u not visited:
            parent[u] = v
            DFS(G, u)

Key structure:

\boxed{\text{recursion / stack}}

83. A useful comparison mental model

Think of exploring a building.

BFS

Check:

every room 1 door away
then every room 2 doors away
then 3 doors away

Good for shortest number of doors.

DFS

Pick one corridor and keep walking until it ends.

Then backtrack.

Good for fully exploring branches.

84. Full graph-analysis example

Suppose:


text
A — B — D
|   |
C — E

Vertices:

V=\{A,B,C,D,E\}.

Edges:

E= \{ \{A,B\}, \{A,C\}, \{B,D\}, \{B,E\} \}.

So:

|V|=5

and:

|E|=4.

Degrees:

\deg(A)=2

\deg(B)=3

\deg(C)=1

\deg(D)=1

\deg(E)=1.

Sum:

2+3+1+1+1=8.

And:

2|E|=8.

Handshaking lemma confirmed.

85. Is this graph a tree?

It has:

5

vertices and:

4

edges.

It is connected and has no cycles.

Therefore:

\boxed{\text{yes, it is a tree}}

86. BFS from $A$

Possible BFS:

A,B,C,D,E.

Layers:

L_0=\{A\}

L_1=\{B,C\}

L_2=\{D,E\}.

So shortest distance from

A

E

2.

87. DFS from $A$

Depending on neighbor ordering, one valid DFS:

A,B,D,E,C.

Another could differ.

Again:

traversal order depends on tie-breaking.

88. Week 10 formula/fact sheet

Graph

\boxed{G=(V,E)}

Handshaking lemma

\boxed{ \sum_v\deg(v)=2|E| }

Complete undirected graph

\boxed{ |E|=\frac{n(n-1)}2 }

BFS complexity

\boxed{ O(V+E) }

DFS complexity

\boxed{ O(V+E) }

Tree

For a tree:

\boxed{ |E|=|V|-1 }

DAG

\boxed{ \text{directed + no directed cycle} }

89. Week 10 conceptual map


text
Graph G=(V,E)
│
├── vertices
├── edges
├── degree
├── paths
├── cycles
└── connectivity
     │
     ▼
Representation
├── adjacency matrix
└── adjacency list
     │
     ▼
Traversal
├── BFS → queue → layers → shortest unweighted path
└── DFS → stack → depth → backtracking
     │
     ▼
Structure
├── components
├── trees
└── DAGs
     └── dependency ordering

90. What you should actually master

By the end of Week 10, you should be able to:

Define:
- graph
- vertex
- edge.
Distinguish directed and undirected graphs.
Compute vertex degree.
Compute in-degree and out-degree.
Apply the handshaking lemma.
Identify paths and cycles.
Determine connectivity/components.
Construct/read adjacency matrices.
Construct/read adjacency lists.
Explain BFS.
Trace BFS manually.
Explain why BFS gives shortest paths in unweighted graphs.
Explain DFS.
Trace DFS manually.
Distinguish queue-based BFS from stack/recursive DFS.
Recognize a tree.
Use:

|E|=|V|-1

appropriately for trees. 18. Recognize a DAG. 19. Understand dependency/topological-order intuition. 20. Know BFS/DFS traversal complexity:

O(V+E).

If those are comfortable, Week 10 is under control.

Quick Recall & Flashcards

Test your active recall before proceeding to practice problems. Format:

Question :: Answer.

Handshaking Lemma for undirected graph $G = (V, E)$ :: $\sum_{v \in V} \deg(v) = 2|E|$
Maximum number of edges in simple undirected graph with $n$ vertices :: $\binom{n}{2} = \frac{n(n-1)}{2}$
Maximum number of directed edges in simple digraph with $n$ vertices :: $n(n-1)$
Breadth-First Search (BFS) primary data structure :: Queue (FIFO) — finds shortest paths in unweighted graphs
Depth-First Search (DFS) primary data structure :: Stack (LIFO) or recursion
Number of edges in a tree with $n$ vertices :: $n - 1$
DAG stands for :: Directed Acyclic Graph
A directed graph has a topological sort if and only if :: It contains no directed cycles (it is a DAG)

Practice & Self-Check

Attempt these diagnostic questions to verify your operational understanding.

Question 1

An undirected graph has 6 vertices, each of degree 3. How many edges does the graph have?

NAT

3 Unit Assessment

Question 2

Which data structure is fundamentally used to implement Breadth-First Search (BFS)?

MCQ

3 Unit Assessment

A. Stack (LIFO)

B. Queue (FIFO)

C. Priority Queue

D. Binary Search Tree