Week 11: Shortest Paths, Transitive Closure & Matrix Powers

3517 words

18 min read

2026-09-12T00:00:00.000Z

Visual companion

Python

Type and operator map

Python Week 1: the first filter for runtime behavior

Open gallery Related surface

View

Revision summary

What this note is really saying

Short form

Weighted graphs, relaxation, Dijkstra, Bellman-Ford, negative cycles, DAG longest paths, and adjacency matrix powers. # Mathematics I — Week 11: Shortest Paths, Transitive Closure & Matrix Powers IITM’s Week 11 covers **longest path, transitive closure, matrix multiplication in graph settings, and single-source shor...

Mathematics I — Week 11: Shortest Paths, Transitive Closure & Matrix Powers

IITM’s Week 11 covers longest path, transitive closure, matrix multiplication in graph settings, and single-source shortest paths including Dijkstra’s and Bellman–Ford algorithms.

TL;DR

Week 10 taught how to traverse graphs.

Week 11 asks:

How do we compute richer path information?

The main ideas are:

shortest path vs longest path
weighted graphs
DAG longest path intuition
reachability
transitive closure
adjacency matrices and matrix powers
single-source shortest path
Dijkstra’s algorithm
Bellman–Ford algorithm
negative edge weights

1. Weighted graphs

A weighted graph assigns a numerical value to each edge.

Example:


text
A --5-- B --2-- C
 \      |
  9     1
   \    |
     D

Weights might represent:

distance
time
cost
probability-related score
energy
latency

Formally, an edge may have weight:

w(u,v).

2. Path weight

For a path:

v_0\to v_1\to \cdots \to v_k,

its total weight is:

\boxed{ \sum_{i=0}^{k-1} w(v_i,v_{i+1}) }

Example:

If:

A\to B

has weight

4

, and:

B\to C

has weight

7

then path:

A\to B\to C

has total weight:

4+7=11.

3. Shortest-path problem

Given two vertices

s

and

t

Find a path from $s$ to $t$ with minimum total weight.

For unweighted graphs, BFS solves this when each edge effectively has equal cost.

For weighted graphs, we need algorithms like:

Dijkstra
Bellman–Ford

4. Single-source shortest path

Instead of solving for one target, we often ask:

From one source $s$ , find shortest distances to every reachable vertex.

This is the single-source shortest-path problem, often abbreviated SSSP.

Output:

d[v]

for every vertex

v

, where:

d[v]

is shortest known distance from source

s

v

5. Relaxation — the core idea

Most shortest-path algorithms repeatedly perform relaxation.

Suppose we know:

d[u]

and have edge:

u\to v

with weight:

w(u,v).

If:

d[u]+w(u,v)<d[v],

then update:

\boxed{ d[v]=d[u]+w(u,v) }

and often:

parent[v]=u.

This means:

We found a cheaper route to $v$ through $u$ .

6. Example of relaxation

Suppose:

d[A]=5

and:

A\to B

has weight:

3.

Current:

d[B]=12.

Going through

A

gives:

5+3=8.

Since:

8<12,

we update:

\boxed{d[B]=8}

7. Initial shortest-path setup

For source:

s,

initialize:

d[s]=0.

For every other vertex:

d[v]=\infty.

Why infinity?

Because initially we know no path to those vertices.

Then relax edges to improve estimates.

8. Dijkstra’s algorithm

Dijkstra solves single-source shortest paths when edge weights are nonnegative.

Core idea:

Repeatedly finalize the currently closest unprocessed vertex.

It is a greedy algorithm.

9. Dijkstra intuition

Suppose source is

A

At every step:

choose unvisited vertex with smallest current distance
finalize it
relax all outgoing edges
repeat

Once a vertex is finalized, its shortest distance is guaranteed correct — provided all edge weights are nonnegative.

10. Dijkstra example

Consider:


text
A --4--> B
|        |
1        1
v        v
C --2--> D

Source:

A.

Initialize:

d[A]=0

d[B]=d[C]=d[D]=\infty.

From

A

d[B]=4

d[C]=1.

Choose smallest unvisited:

C

with distance:

1.

Relax:

C\to D

weight

2

d[D]=1+2=3.

Now smallest is:

D=3.

Then:

B=4.

So final shortest distances:

\boxed{ d[A]=0,\quad d[C]=1,\quad d[D]=3,\quad d[B]=4 }

11. Why Dijkstra works

The greedy step relies on:

w(e)\geq0.

If we already selected the vertex with smallest tentative distance, no future path through unprocessed vertices can make it smaller using nonnegative edges.

That guarantee breaks with negative weights.

12. Negative-weight problem

Suppose:


text
A --2--> B
|        ^
5        |
v       -10
C -------

Initially Dijkstra may think:

d[B]=2.

But path:

A\to C\to B

costs:

5+(-10)=-5.

So a later negative edge can improve a vertex that seemed already finalized.

That breaks Dijkstra's logic.

13. Dijkstra restriction

You should memorize:

\boxed{ \text{Dijkstra requires nonnegative edge weights} }

Zero-weight edges are fine.

Negative edges are not.

14. Dijkstra pseudocode intuition


text
dist[source] = 0
all others = infinity

while unprocessed vertices remain:
    choose u with smallest dist[u]
    mark u processed

    for each edge u -> v:
        if dist[u] + w(u,v) < dist[v]:
            update dist[v]

Efficient implementations typically use a priority queue.

15. Dijkstra complexity

With a binary heap / priority queue:

\boxed{ O((V+E)\log V) }

often simplified to:

O(E\log V)

for connected sparse graphs.

A simpler array/matrix implementation may be:

O(V^2).

For exam purposes, context matters.

16. Bellman–Ford algorithm

Bellman–Ford also solves single-source shortest paths.

But unlike Dijkstra, it can handle:

\boxed{\text{negative edge weights}}

as long as there is no reachable negative-weight cycle that makes shortest paths undefined.

17. Bellman–Ford core idea

Instead of greedily finalizing vertices, Bellman–Ford repeatedly relaxes all edges.

For a graph with:

|V|=n,

repeat edge relaxation:

n-1

times.

Why?

Any simple path can contain at most:

n-1

edges.

18. Bellman–Ford procedure

Initialize:

d[s]=0

and all others infinity.

Then:


text
repeat |V|-1 times:
    for every edge (u,v):
        relax(u,v)

After that, one additional pass can test for negative cycles.

19. Why $|V|-1$ iterations?

A shortest simple path cannot repeat a vertex.

If it repeated a vertex, that contains a cycle.

A simple path on

|V|

vertices uses at most:

|V|-1

edges.

After the first relaxation round, shortest paths of at most one edge can propagate.

After two rounds, two-edge paths.

Eventually:

|V|-1

edges are enough.

20. Bellman–Ford example

Suppose:


text
S --4--> A
|        |
5       -2
v        v
B --1--> C

There may be alternative routes.

Bellman–Ford repeatedly examines all edges and improves estimates whenever possible.

The important conceptual point is:

improvements are allowed even if a vertex was already improved before.

Nothing is permanently finalized too early.

21. Negative cycles

A negative cycle is a directed cycle whose total weight is negative.

Example:

A\to B

weight

2

B\to C

weight

-5

C\to A

weight

1

Total:

2-5+1=-2.

22. Why negative cycles break shortest paths

Suppose a path can reach a negative cycle.

You could traverse that cycle repeatedly:

-2,-4,-6,-8,\dots

making path cost arbitrarily small.

So there is no finite "shortest" path.

Mathematically:

\boxed{ \text{shortest distance}=-\infty }

in the limiting sense.

23. Detecting negative cycles with Bellman–Ford

After:

|V|-1

full relaxation rounds, perform one more.

If any distance can still decrease, then:

\boxed{ \text{reachable negative cycle exists} }

This is a major advantage of Bellman–Ford.

24. Bellman–Ford complexity

Bellman–Ford scans all

E

edges for roughly

V

rounds.

Therefore:

\boxed{ O(VE) }

This is slower than Dijkstra on ordinary nonnegative graphs.

25. Dijkstra vs Bellman–Ford

Dijkstra	Bellman–Ford
greedy	repeated relaxation
nonnegative weights	negative weights allowed
faster	slower
usually priority queue	scan all edges
cannot detect negative cycles properly	can detect reachable negative cycles

High-value rule:

\boxed{ \text{Negative edges? Think Bellman–Ford.} }

26. BFS vs Dijkstra

BFS can be viewed as a special shortest-path algorithm where every edge has identical weight:

1.

So:

Unweighted / equal-weight graph

Use BFS.

Nonnegative weighted graph

Use Dijkstra.

Negative weights

Use Bellman–Ford.

This taxonomy is worth memorizing.

27. Shortest-path algorithm decision table

Graph	Preferred basic algorithm
unweighted	BFS
weighted, all weights $\geq0$	Dijkstra
negative weights, no problematic negative cycle	Bellman–Ford
DAG	topological-order dynamic programming can be even simpler

28. Longest-path problem

Now reverse the goal:

Find a path with maximum total weight or maximum number of edges.

This sounds like simply modifying shortest path.

Unfortunately, in general graphs, longest path is much harder.

29. Why arbitrary longest path is difficult

If cycles are allowed, you can potentially keep looping.

Even when restricting to simple paths, the general longest-path problem is computationally difficult.

But on a DAG, the problem becomes manageable.

This is why DAGs from Week 10 matter.

30. Longest path in a DAG

Because a DAG has no cycles, vertices can be arranged in topological order.

Then compute longest distances in that order.

Conceptually:

\boxed{ d[v] = \max_{u\to v} \left(d[u]+w(u,v)\right) }

This resembles shortest-path relaxation, but uses:

\max

instead of:

\min.

31. Example DAG


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

Suppose weights:

A\to B=2

A\to C=5

B\to D=4

C\to D=3.

Possible paths to

D

A\to B\to D: \quad2+4=6

A\to C\to D: \quad5+3=8.

So longest path from

A

D

has weight:

\boxed{8}

32. Longest path as scheduling

A DAG may represent tasks:


text
A → B → D
 \→ C ─→

Suppose edge/node weights represent durations.

The longest dependency chain determines the critical path.

This is important in:

project scheduling
build systems
dependency planning
workflow optimization

33. Reachability

A vertex:

v

is reachable from:

u

if there exists a directed path:

u\leadsto v.

We often want to know reachability for every pair of vertices.

That leads to transitive closure.

34. Transitive closure

The transitive closure of a directed graph adds an edge:

u\to v

whenever

v

is reachable from

u

So it converts:

path exists

into:

direct relation in the closure.

35. Example

Original:


text
A → B → C

Since:

A\leadsto C,

the transitive closure also contains:

A\to C.

Closure:


text
A → B → C
 \------→

36. Relation-theory connection

Recall Week 1 transitivity:

aRb

and:

bRc

implies:

aRc.

Transitive closure means:

Add the minimum required relationships so the relation becomes transitive.

So Week 11 reconnects directly to Week 1.

37. Reachability matrix

For vertices:

v_1,\dots,v_n,

define matrix:

R

where:

R_{ij}= \begin{cases} 1,&v_j\text{ reachable from }v_i\\ 0,&\text{otherwise} \end{cases}

This is essentially an adjacency matrix of the transitive closure.

38. Adjacency matrix recap

For graph

G

, adjacency matrix:

A_{ij}=1

if edge:

i\to j

exists.

Otherwise:

A_{ij}=0.

Matrix multiplication reveals deeper path information.

39. Why $A^2$ is interesting

Consider:

(A^2)_{ij}.

By matrix multiplication:

(A^2)_{ij} = \sum_k A_{ik}A_{kj}.

Each term:

A_{ik}A_{kj}

equals

1

exactly when:

i\to k

and:

k\to j.

Therefore:

\boxed{ (A^2)_{ij} }

counts walks of length:

2

from

i

j

40. General matrix-power interpretation

More generally:

\boxed{ (A^k)_{ij} }

counts the number of walks of length:

k

from vertex

i

to vertex

j

This is a major connection between linear algebra and graph theory.

41. Example

Suppose:


text
A → B → C

Adjacency matrix in order

A,B,C

A= \begin{pmatrix} 0&1&0\\ 0&0&1\\ 0&0&0 \end{pmatrix}.

Then:

A^2= \begin{pmatrix} 0&0&1\\ 0&0&0\\ 0&0&0 \end{pmatrix}.

The

1

in position

(A,C)

indicates one walk of length

2

A\to B\to C.

42. Reachability from matrix powers

A path between distinct vertices can have length at most:

|V|-1

if considering a simple path.

So reachability information is related to:

A+A^2+\cdots+A^{n-1}.

If the

(i,j)

entry is nonzero somewhere in these powers, then:

j

is reachable from:

i.

For Boolean reachability, we care about existence, not count.

43. Boolean matrix viewpoint

Instead of ordinary arithmetic:

multiplication behaves like AND
addition behaves like OR

Then matrix multiplication can directly encode reachability.

This is sometimes called Boolean matrix multiplication.

Conceptually:

1\land1=1

means both required edges exist.

And:

1\lor1=1

means at least one path exists.

44. Transitive closure via repeated paths

One conceptual formula is:

R = I\lor A\lor A^2\lor\cdots

depending on whether self-reachability is included.

Here:

I

represents length-

0

paths:

v\leadsto v.

The exact convention may vary, so check whether the relation is defined reflexively.

45. Matrix multiplication definition

For:

A\in\mathbb R^{m\times n}

and:

B\in\mathbb R^{n\times p},

the product:

C=AB

has size:

m\times p.

Each entry:

\boxed{ C_{ij} = \sum_{k=1}^n A_{ik}B_{kj} }

Graph applications rely heavily on this formula.

46. Matrix-dimension rule

If:

A

is:

m\times n

and:

B

is:

r\times p,

then:

AB

exists only when:

\boxed{n=r}.

Result size:

\boxed{m\times p}.

47. Matrix multiplication is not commutative

In general:

\boxed{ AB\neq BA }

and one product may exist when the reverse doesn't.

This matters because directed graph structure itself is order-sensitive.

48. Path reconstruction in shortest-path algorithms

Distances tell us cost.

To recover the actual path, maintain:

parent[v].

Whenever relaxation improves:

d[v],

set:

parent[v]=u.

Then trace backward from target.

49. Example

Suppose final parents are:

parent[D]=C

parent[C]=B

parent[B]=A.

Then path to

D

backwards:

D\leftarrow C\leftarrow B\leftarrow A.

Reverse:

\boxed{ A\to B\to C\to D }

50. Triangle inequality intuition for shortest paths

Shortest-path distances satisfy:

\boxed{ d(s,v) \leq d(s,u)+w(u,v) }

If the inequality is violated by our current estimates, relaxation fixes it.

So relaxation is repeatedly enforcing shortest-path consistency.

51. Dijkstra full small example

Consider:


text
S --2--> A --3--> C
|        |
5        1
v        v
B --1--> C

Source:

S.

Initialize:

d[S]=0

others infinity.

From

S

d[A]=2

d[B]=5.

Choose

A

2.

Relax:

A\to C: \quad2+3=5.

So:

d[C]=5.

Suppose:

A\to B

has weight

1

Then:

2+1=3<5.

Update:

d[B]=3.

Choose

B

3.

Relax:

B\to C

weight

1

3+1=4<5.

So:

d[C]=4.

Final:

\boxed{ d[S]=0,\quad d[A]=2,\quad d[B]=3,\quad d[C]=4 }

52. Why greedy order mattered

Dijkstra processes:

S\to A\to B\to C

based on smallest tentative distance, not alphabetical order or graph depth.

This is a common misunderstanding.

Common mistake: Dijkstra with negative edges

Do not.

Even one negative edge can invalidate its finalized-distance assumption.

Use Bellman–Ford or another appropriate method.

Common mistake: Bellman–Ford needs all cycles absent

No.

Bellman–Ford can work with cycles.

The problem is a reachable:

\boxed{\text{negative-weight cycle}}

not cycles in general.

Positive or zero-weight cycles are fine for shortest-path existence.

Common mistake: negative edge = negative cycle

These are different.

A graph may contain a negative edge but no negative cycle.

Example:


text
A --(-3)--> B → C

No return route means no cycle.

Bellman–Ford can still compute shortest paths.

Common mistake: longest path = negate weights + Dijkstra

Not generally.

Negating weights creates negative edges, which Dijkstra cannot handle.

And arbitrary longest simple paths are fundamentally harder.

On DAGs, use topological structure.

Common mistake: adjacency matrix power counts simple paths

Not necessarily.

(A^k)_{ij}

counts walks of length

k

Walks may repeat vertices and edges.

That is different from simple paths.

Common mistake: transitive closure stores distance

No.

Transitive closure answers:

\boxed{\text{reachable or not?}}

It doesn't inherently store:

shortest distance
number of paths
path weight

Those are different graph problems.

Common mistake: shortest path means fewest edges

Only in unweighted/equal-weight graphs.

Weighted shortest path minimizes:

\boxed{\text{total edge weight}}

A path with more edges can still be cheaper.

60. Example

Path 1:

A\to B

one edge of weight:

100.

Path 2:

A\to C\to D\to B

three edges of weights:

1+1+1=3.

Weighted shortest path is Path 2.

61. Algorithm selection mental map


text
Need shortest path?
│
├── unweighted / equal weights
│      └── BFS
│
├── weighted and all weights >= 0
│      └── Dijkstra
│
├── negative weights possible
│      └── Bellman–Ford
│
└── DAG
       └── topological-order DP

This is extremely useful for exam reasoning.

62. Week 11 formula/fact sheet

Relaxation

\boxed{ d[v]\leftarrow \min(d[v],d[u]+w(u,v)) }

Dijkstra condition

\boxed{ w(e)\geq0 }

Bellman–Ford rounds

\boxed{ |V|-1 }

Bellman–Ford complexity

\boxed{ O(VE) }

Adjacency powers

\boxed{ (A^k)_{ij} = \text{number of length-}k\text{ walks from }i\text{ to }j }

DAG longest-path recurrence

\boxed{ d[v] = \max_{u\to v} (d[u]+w(u,v)) }

63. Week 11 conceptual map


text
Weighted Graphs
│
├── path weight
├── relaxation
│
├── shortest paths
│   ├── BFS
│   ├── Dijkstra
│   └── Bellman–Ford
│
├── longest path
│   └── tractable on DAGs
│
├── reachability
│   └── transitive closure
│
└── adjacency matrix
    └── A^k → walks of length k

64. How Week 10 and Week 11 connect

Week 10:

\text{Can I reach this vertex?}

Week 11:

\text{What is the best path?}

and:

\text{Which vertices are reachable from which others?}

So the progression is:

\boxed{ \text{traversal} \rightarrow \text{reachability} \rightarrow \text{weighted optimization} }

65. What you should actually master

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

Understand weighted graphs.
Compute total path weight.
Explain single-source shortest paths.
Perform a relaxation step.
Trace basic Dijkstra examples.
Know why Dijkstra requires nonnegative weights.
Trace basic Bellman–Ford logic.
Understand why Bellman–Ford uses $|V|-1$ rounds.
Recognize and explain negative-weight cycles.
Distinguish negative edges from negative cycles.
Choose between BFS, Dijkstra and Bellman–Ford.
Understand longest-path reasoning in DAGs.
Define reachability.
Define transitive closure.
Read/write adjacency matrices.
Multiply small matrices.
Understand: $(A^k)_{ij}$ as counting length- $k$ walks.
Distinguish walks from simple paths.
Understand path reconstruction with parents.

If those are comfortable, Week 11 is under control.

Quick Recall & Flashcards

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

Question :: Answer.

Relaxation step for edge $(u, v)$ with weight $w(u, v)$ :: If $dist[u] + w(u, v) < dist[v]$ : $dist[v] = dist[u] + w(u, v)$
Dijkstra's algorithm requirement :: All edge weights must be nonnegative ( $w(u, v) \ge 0$ )
Bellman–Ford algorithm number of relaxation rounds :: $|V| - 1$ rounds over all edges
How Bellman–Ford detects negative-weight cycles :: A negative cycle exists if an edge can still be relaxed in the $|V|$ -th round
Adjacency matrix power $(A^k)_{ij}$ interpretation :: Number of walks of length exactly $k$ from vertex $i$ to vertex $j$
Transitive closure definition :: Reachability matrix indicating if a path of any length exists from $i$ to $j$
Algorithm for single-source shortest path in DAG with arbitrary weights :: Topological sort + single relaxation pass in $O(|V| + |E|)$

Practice & Self-Check

Attempt these diagnostic questions to verify your operational understanding.

Question 1

Which algorithm is suitable for finding single-source shortest paths in a directed graph that contains negative edge weights but no negative cycles?

MCQ

3 Unit Assessment

A. Dijkstra’s Algorithm

B. Bellman–Ford Algorithm

C. Standard unweighted BFS

D. Kruskal’s Algorithm

Question 2

Let

A

be the adjacency matrix of an unweighted graph. The entry

(A^3)_{ij}

represents:

MCQ

3 Unit Assessment

A. The shortest distance between vertex

i

and vertex

j

B. The number of walks of length exactly 3 from vertex

i

to vertex

j

C. The weight of edge

(i, j)

cubed

D. Whether

i

and

j

belong to the same component

What this note is really saying

Mathematics I — Week 11: Shortest Paths, Transitive Closure & Matrix Powers

TL;DR

1. Weighted graphs

2. Path weight

3. Shortest-path problem

4. Single-source shortest path

5. Relaxation — the core idea

6. Example of relaxation

7. Initial shortest-path setup

8. Dijkstra’s algorithm

9. Dijkstra intuition

10. Dijkstra example

11. Why Dijkstra works

12. Negative-weight problem

13. Dijkstra restriction

14. Dijkstra pseudocode intuition

15. Dijkstra complexity

16. Bellman–Ford algorithm

17. Bellman–Ford core idea

18. Bellman–Ford procedure

19. Why ∣V∣−1|V|-1∣V∣−1 iterations?

20. Bellman–Ford example

21. Negative cycles

22. Why negative cycles break shortest paths

23. Detecting negative cycles with Bellman–Ford

24. Bellman–Ford complexity

25. Dijkstra vs Bellman–Ford

26. BFS vs Dijkstra

Unweighted / equal-weight graph

Nonnegative weighted graph

Negative weights

27. Shortest-path algorithm decision table

28. Longest-path problem

29. Why arbitrary longest path is difficult

30. Longest path in a DAG

31. Example DAG

32. Longest path as scheduling

33. Reachability

34. Transitive closure

35. Example

36. Relation-theory connection

37. Reachability matrix

38. Adjacency matrix recap

39. Why A2A^2A2 is interesting

40. General matrix-power interpretation

41. Example

42. Reachability from matrix powers

43. Boolean matrix viewpoint

44. Transitive closure via repeated paths

45. Matrix multiplication definition

46. Matrix-dimension rule

47. Matrix multiplication is not commutative

48. Path reconstruction in shortest-path algorithms

49. Example

50. Triangle inequality intuition for shortest paths

51. Dijkstra full small example

52. Why greedy order mattered

60. Example

61. Algorithm selection mental map

62. Week 11 formula/fact sheet

Relaxation

Dijkstra condition

Bellman–Ford rounds

Bellman–Ford complexity

Adjacency powers

DAG longest-path recurrence

63. Week 11 conceptual map

64. How Week 10 and Week 11 connect

65. What you should actually master

Quick Recall & Flashcards

Practice & Self-Check

Question 1

Question 2

Active Recall Session

19. Why $|V|-1$ iterations?

39. Why $A^2$ is interesting