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.

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.

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.

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.

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.

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.

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.

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$.

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