🖨️ Printing Instructions: Press Ctrl/Cmd + P and select "Save as PDF".

Dijkstra's Algorithm

Learning Goals

Understand the Single-Source Shortest Path problem.
Master the Relaxation technique.
Learn Dijkstra's Algorithm and its correctness proof.
Analyze complexity with different priority queue implementations.
Understand why Dijkstra fails with negative edges.

The Shortest Path Problem

Goal

Given weighted graph $G=(V,E)$ and source vertex $s$.
Find shortest path (minimum total weight) from $s$ to all $v \in V$.
Important: Directed or undirected. Weights must be non-negative for Dijkstra.

Shortest Path Variants

Single-Source (SSSP): One start, all destinations. (Dijkstra, Bellman-Ford).
Single-Destination: Reverse graph, run SSSP.
All-Pairs (APSP): All starts, all destinations. (Floyd-Warshall).
Unweighted: Use BFS in $O(V+E)$.

Optimal Substructure

Subpaths of shortest paths are shortest paths.
If shortest path $s \to v$ goes through $u$, then $s \to u$ must also be a shortest path.
Proof by cut and paste argument (contradiction).
This property is what makes both greedy and DP approaches possible.

Relaxation

Interactive Demo

🚀 Interactive Demo: relaxation_demo.html

The Core Operation

Maintain an estimate $d[v]$ — an upper bound on the true distance.
Initially $d[s]=0$, all others $d[v]=\infty$.
Relaxing edge $(u, v)$: Can we improve the path to $v$ by going through $u$?
If $d[u] + w(u, v) < d[v]$, then update $d[v] = d[u] + w(u, v)$.
Also store predecessor: $\pi[v] = u$ (for path reconstruction).

Relax(u, v, w)

if d[v] > d[u] + w(u, v)
  d[v] = d[u] + w(u, v)
  pi[v] = u

Properties of Relaxation

Upper-bound property: $d[v] \geq \delta(s, v)$ always (estimates never go below true distance).
No-path property: If no path exists, $d[v] = \infty$ forever.
Convergence: Once $d[v] = \delta(s, v)$, it never changes.
Relaxation is safe — it only improves estimates, never worsens them.

Dijkstra's Algorithm

Interactive Demo

🚀 Interactive Demo: dijkstra_demo.html

Greedy Strategy

Maintain set $S$ of vertices whose final shortest-path weights are known.
Repeatedly select vertex $u \in V-S$ with minimum estimate $d[u]$.
Add $u$ to $S$ (finalize it).
Relax all edges leaving $u$.
Key insight: With non-negative weights, the minimum estimate is always correct.

Dijkstra(G, s)

Init-Single-Source(G, s) // d[s]=0, others inf
S = empty
Q = V // Min-Priority Queue keyed by d[]
while Q not empty
  u = Extract-Min(Q)
  S = S U {u}
  for each v in Adj[u]
    Relax(u, v, w)

Example Trace

Graph: $s \to A$ (weight 10), $s \to B$ (weight 5), $B \to A$ (weight 3).
Init: $d[s]=0$, $d[A]=\infty$, $d[B]=\infty$.
Pop $s$: Relax $s \to A$: $d[A]=10$. Relax $s \to B$: $d[B]=5$.
Pop $B$ (min=5): Relax $B \to A$: $5+3=8 < 10$, update $d[A]=8$.
Pop $A$ (min=8): Done. Shortest paths: $s \to B = 5$, $s \to A = 8$.

Similarity to Prim's MST

Both use a min-priority queue and greedy extraction.
Both process each vertex once.
Prim: Key is edge weight to tree (closest edge to MST).
Dijkstra: Key is total distance from source (shortest path so far).
Same structure, different comparison criteria.

Analysis

Complexity

Initialization: $O(V)$.
While loop: $V$ Extract-Min operations.
For loops: Total $E$ Relax (Decrease-Key) operations.
Array implementation: $O(V^2)$ — good for dense graphs.
Binary Heap: $O(E \log V)$ — good for sparse graphs.
Fibonacci Heap: $O(V \log V + E)$ — theoretical best.

Priority Queue Comparison

Implementation	Extract-Min	Decrease-Key	Total
Array	$O(V)$	$O(1)$	$O(V^2)$
Binary Heap	$O(\log V)$	$O(\log V)$	$O(E \log V)$
Fibonacci Heap	$O(\log V)$ amortized	$O(1)$ amortized	$O(V \log V + E)$

Complexity depends on the priority queue implementation

Correctness Proof

Theorem

Theorem: Dijkstra's algorithm terminates with $d[u] = \delta(s, u)$ for all $u \in V$.
Requirement: All edge weights are non-negative, $w(e) \geq 0$.

Proof Sketch (Loop Invariant)

Invariant: For every $v \in S$, $d[v] = \delta(s, v)$.
Base case: $S = \emptyset$, trivially true.
Inductive step: When adding $u$ to $S$, suppose $d[u] \neq \delta(s, u)$.
Then there exists a shorter path $P$ from $s$ to $u$.
Path $P$ must leave $S$ at some vertex $x$ via edge $(x, y)$ where $y \notin S$.
But $d[y] \leq d[x] + w(x,y) = \delta(s,y)$, and any extension from $y$ to $u$ adds non-negative weight.
So $d[y] \leq \delta(s,u) < d[u]$, contradicting that $u$ was extracted as the minimum.

Limitations & Negative Edges

Interactive Demo

🚀 Interactive Demo: negative_edge_demo.html

Why Dijkstra Fails with Negatives

Dijkstra's greedy assumption: once a vertex is finalized, its distance is correct.
With negative edges, a longer path through more vertices can become shorter later.
The algorithm "finalizes" nodes too early — it cannot undo past decisions.
Example: $s \to A$ (weight 1), $s \to B$ (weight 5), $B \to A$ (weight $-10$).
Dijkstra finalizes $A$ with $d[A]=1$, but the true shortest path is $s \to B \to A = -5$.

Negative Cycles

A negative-weight cycle makes shortest path undefined ($-\infty$).
We can keep going around the cycle to reduce cost indefinitely.
Bellman-Ford algorithm handles negative edges and detects negative cycles.
We will study it in the next lecture.

Path Reconstruction

Building the Actual Path

Dijkstra gives distances $d[v]$, but how do we find the actual path?
During relaxation, store predecessor $\pi[v] = u$ whenever $d[v]$ is updated.
To reconstruct path to vertex $t$: backtrack $t \to \pi[t] \to \pi[\pi[t]] \to \ldots \to s$.
Reverse the sequence to get the forward path.
The predecessor array $\pi$ defines a shortest-path tree rooted at $s$.

Common Pitfalls

Watch Out For...

Using Dijkstra with negative edge weights — use Bellman-Ford instead.
Forgetting to initialize $d[s]=0$ and all other $d[v]=\infty$.
Not using a proper min-priority queue — array is $O(V^2)$, heap is $O(E \log V)$.
Confusing Dijkstra with Prim's — Prim uses edge weight to tree, Dijkstra uses total distance from source.
Forgetting path reconstruction — store $\pi[v]$ during relaxation to recover the actual path.

All Interactive Demos

🚀 Interactive Demo: relaxation_demo.html

🚀 Interactive Demo: dijkstra_demo.html

🚀 Interactive Demo: negative_edge_demo.html

Lecture Summary

Shortest-Path Problem: Given weighted graph and source $s$, find minimum-cost paths. Requires non-negative weights for Dijkstra.
Relaxation: Core operation — if $d[u] + w(u,v) < d[v]$, update estimate and predecessor. Safe and monotonic.
Dijkstra's Algorithm: Greedy extraction from min-priority queue. Finalize closest unvisited vertex, relax its edges.
Complexity: Array $O(V^2)$ for dense, binary heap $O(E \log V)$ for sparse, Fibonacci heap $O(V \log V + E)$ best.
Negative Edges: Dijkstra fails — it finalizes too early. Next lecture: Bellman-Ford and Floyd-Warshall.

Supplementary Resources

🚀 Interactive Demo: worked_examples.html

🚀 Interactive Demo: reading_practice.html

🚀 Interactive Demo: handout.html