1.0 - Shortest Path

• A path $p$ from $v_1$ to $v_n$ is a sequence of vertices:

  $$v_1\rightarrow v_2\rightarrow v_3 \rightarrow\cdots\rightarrow v_n$$

• The total weight of the path, $\text{weight(p)}$ is the sum of the edges along the path’

  $$\text{weight(p)}=\sum^{n-1}_{i=1} \text{weight}(v_1, v_{i+1})$$

• The distance from $v_1$ to $v_n$ is the minimum weight of all paths from $v_1\rightarrow v_n$

• The shortest path frp, $v_1$ to $v_n$ is a path from $v_1$ to $v_n$ of minimum weight

1.1 - Types of Shortest Paths

1. Single-Pair Given a pair $(u, v)$, find a shortest path between them
2. Single-Source Given a vertex $v$, find a shortest path to every other vertex
3. Single-Destination Given a vertex $v$, find a shortest path from every other vertex
4. All-Pairs Given a graph, find a shortest path between every pair of vertices

1.1.1 - Single-Source Shortest Path

Given a graph $G$, with weight function $w$ and a source vertex $s$, calculate for each vertex:

• $v.d$ Distance from source vertex
• $v.\pi$ The predecessor to $v$ on a shortest path from $s$ to $v$

The steps to this algorithm are:

1. Initialise $s.d=0$ and $v.d=0$ for all vertices $v\in G.V-\{s\}$
   • We have the invariant that $\text{distance}(s,v)\le v.d\le \infty$
2. Initialise $v.\pi=\text{NULL}$ for all vertices $v\in G.V$
   • Invariant $v.\pi$ is v’s predecessor on the shortest path found so far
3. Improve upper bound estimates until they reach a solution

Can we improve our estimate $\text{distance}(s,v)\le \color{lightgreen}v.d$ based on:

• Our estimate $\text{distance}(s, u)\le \color{pink}u.d$ and
• The existence of edge $(u,v)$ with weight $\color{pink}w(u,v)$

We know that:

And thus, we know that

1.1.2 - Edge Relaxation Algorithm

relax(u, v, w):
	improves estimate distance(s,v) ≤ v.d if possible, based on:
		our estimate distance(s, u) ≤ u.d and
		the existence of edge (u,v) with weight w(u,v)

relax(u, v, w)
	if v.d > u.d + w(u,v)
		v.d = u.d + w(u,v)
		v.π = u

• This preserves the distance and predecessor invariants:
  • Invariant $\text{distance}(s,v)\le v.d\le\infty$
  • Invariant $v.\pi$ is $v$’s predecessor on the shortest path sound so far
• Does not change $v.d$ and $v.\pi$ if the shortest path to $v$ has already been found
• The relax(u,v,w) algorithm will find a shortest path from s to v if:
  • A shortest path from $s$ to $v$ has already been found $\text{distance}(s,u)=u.d$
  • Vertex $u$ is $v's$ predecessor on a shortest path from $s\rightarrow v$ $\text{distance}(s,v)=\text{distance}(s,u)+w(u,v)$, and
  • Another shortest path from $s$ to $v$ has not already been found

1.1.3 - Edge Relaxation

Let

be a shortest path from $v_1$ to $v_n$

If edge $(v_{i-1},v_i)$ is relaxed after a shortest path to $v_{i-1}$ is found, we will find a shortest path to $v_i$

We can relax edges in a wa y that guarantees that we find shortest paths from our source vertex $s$ to every other vertex $v\in G.V$ (and is efficient)?

1.2 - Dijkstra’s Algorithm

🌱 Dijkstra’s algorithm is a generalisation of Breadth First Search, but for weighted graphs.

• Solves the single-source shortest paths problem for weighted graphs without negative weight edges.
• AI in computer games use a sophisticated variant called A*
• Solves graphs in order from start vertex

1.2.1 - Shortest Path Algorithm - Steps

• For each vertex $v\in G.V$, we calculate
  • v.d Distance of vertex from the source vertex s
  • v.$\pi$ The predecessor to v on the shortest path from s to v
• Steps:
  • Initialise $s.d$=0 and $v.d$=$\infty$ for all vertices $v\in G.V-{s}$ (all vertices but starting vertex)
    • $s.d$=0 (set the distance of the source vertex to 0)
    • $v.d$=$\infty$ (set distance of all other vertices to source vertex to $\infty$ initially)
    • Invariant that distance(s,v) $\le$ v.d $\le\infty$
  • Initialise $v.\pi$ = NIL for all $v\in G.V$
    • Invariant that $v.\pi$ is a predecessor on the shortest path found so far.
  • Improve Visit each vertex once (after we have found a shortest path to it) in order of its distance from the source vertex - when we visit a vertex, we can relax its outgoing edges

1.2.2 - Efficient Implementation of Dijkstra

🌱 How do we (efficiently) find the next vertex to visit?

• Let S be the set of visited vertices
• We main a priority queue, Q, containing vertices $V-S$, with key $v.d$
• At each step of the algorithm, we visit the vertex $u\leftarrow$ vertex on Q, with minimum key.
  • That is, we remove the element from the PQ
  • We then relax all of its edges.

1.2.3 - Why does Dijkstra’s Algorithm Work?

• When we visit a vertex u, we are guaranteed to have already found a shortest path to u, assuming that the graph has no negative weight edges.
• Suppose v is a predecessor of u on a shortest path from $s\rightarrow u$
• Since our graph doesn’t have negative-weight edges, we know that $\text{distance}(s,v)\le \text{distance}(s,u)$ and so either:
  • We have already visited v and have relaxed its edges, or
  • We have already found another shortest-path to u of length distance(s, u) = distance(s, v)

1.2.4 - Dijkstra’s Algorithm

Dijkstra(G, w, s)
	// (G) Graph, (w) weight function, (s) source vertex
	init_single_source(G, s)
	S = ∅         // S is the set of visited vertices
	Q = G.V       // Q is a priority queue, maintaining G.V - S

  while Q != ∅
			u = extract_min(Q)
			S = S ∪ {u}
      for each vertex in G.adj[u]
          relax(u, v, w)

init_single_source(G, s)
   for each vertex v in G.V
      v.d = ∞
      v.pi = NIL
   s.d = 0

relax(u, v, w)
    if v.d > u.d + w(u,v)
        v.d = u.d + w(u,v)
        v.pi = u

1.2.5 - Analysis of Dijkstra’s Algorithm

• The initialisation (init_single_source) and addition to the priority queue are both completed $\Theta(v)$ time, where $v:$ number of vertices

• We complete the body of the main while loop $\Theta(v)$ times, as a vertex is removed each iteration, and each vertex can only be added to the priority queue once.

• The removal from the priority queue incurs some cost - this depends on the PQ implementation

• We complete the inner for-loop $\text{degree(u)}$ times.

  • Since each edge is removed at least once, we know that the relaxation algorithm is performed exactly $e$ times.

• Thus, the time complexity of the algorithm is

  $$\Theta(V\times T_{\text{extract\_min}}+E\times T_{\text{decrease\_key}})$$

• Using this, we can analyse the performance of Dijkstra’s algorithm, based on the data structures used.

  Q Data Structure	$T_{\text{extract\_min}}$	$T_{\text{decrease\_key}}$	Total
  array	$O(V)$	$O(1)$	$O(V^2)$
  binary heap	$O(\lg V)$	$O(\lg V)$	$O(E \lg V)$
  Fibonacci heap	$O(\lg V)$ amortised	$O(1)$ amortized	$O(E + V \lg V)$ amortised

• Fibonacci heap is an implementation with very large constant factors.