Lecture 25: Shortest Paths

BFS would not be a good choice for a google maps style navigation application
- We need an algorithm that takes into account edge distances, also known as "edge weights"

Dijkstra's Algorithm

Observation: Solution will always be a path with no cycles (assuming non-negative weights)

Goal: Find the shortest paths from source vertex s to every other vertex
Observation: Solution will always be a tree
- Can think of as the union of the shortest paths to all vertices

If G is a connected edge-weighted graph with V vertices and E edges, how many edges are in the Shortest Paths Tree (SPT) of G? [assume every vertex is reachable]
- Since the solution is a tree, there are V-1 edges

Start with a bad algorithm
- Algorithm begins with all vertices unmarked and all distance infinite. No edges in the shortest paths tree (SPT)
Bad algorithm #1: Perform a depth first search. When you visit v:
- For each edge from v to w, if w is not already part of SPT, add the edge
  - Note: This WILL NOT WORK
Bad algorithm #2: Perform a depth first search. When you visit v:
- For each edge from v to w, add edge to the SPT only if that edge yields better distance (we'll call this process "edge relaxation")
- Improvements:
  - Use better edges if found

Dijkstra's:
- PQ.add(source, 0)
- For other vertices v, PQ.add(v, infinity)
- While PQ is not empty:
  - p = PQ.removeSmallest()
  - Relax all edges from p
Relaxing and edge p -> q with weight w:
- If distTo[p] + w < distTo[q]:
  - distTo[q] = distTo[p] + w
  - edgeTo[q] = p
  - PQ.changePriority(q, distTo[q])
Key invariants:
- edgeTo[v] is the best known predecessor of v
- distTo[v] is the best known total distance from source to v
- PQ contains all unvisited vertices in order of distTo
Important properties:
- Always visits vertices in order of total distance from source
- Relaxation always fails on edges to visited (white) vertices

Dijkstra's Algorithm
- Visit vertices in order of best-known distance from source. On visit, relax every edge from the visited source
Guaranteed to return a correct result if all edges are non-negative
- Proof relies on the property that relaxation always fails on edges to visited vertices
Proof sketch: Assume all edges have non-negative weights
- At start, distTo[source] = 0, which is optimal
- After relaxing all edges from source, let vertex v1 be the vertex with minimum weight, i.e. that is closest to the source. Claim: distTo[v1] is optimal, and thus future relaxations will fail. Why?
  - distTo[p] >= distTo[v1] for all p, therefore
  - distTo[p] + w >= distTo[v1]
- Can use induction to prove that this holds for all vertices after dequeuing

Dijkstra's Algorithm
- Visit vertices in order of best-known distance from source. On visit, relax every edge from the visited vertex
Dijkstra's can fail if graph has negative weight edges
- Relaxation of already visited edges can succeed

Priority Queue operation count, assuming binary heap based PQ:
- add: V, each costing O(log V) time
- removeSmallest: V, each costing O(log V) time
- changePriority: E, each costing O(log V) time
Overall runtime: O(V*log(V) + V*log(V) + E*log(V))
- Assuming E > V, this is just O(E log V) for a connected graph

Is this a good algorithm for a navigation application
- Will it find the shortest path?
  - Yes!
- Will it be efficient
  - No. It will look for shortest path to other places

We have only a single target in mind, so we need a different algorithm. How can we do better?

Simple idea:
- Visit vertices in order of d(Denver, v) + h(v, goal), where h(v, goal) is an estimate of the distance from v to our goal NYC
- In other words, look at some location if:
  - We already know the fastest way to reach v
  - AND we suspect that v is also the fastest way to NYC taking into account the time to get to v
Observations:
- Not every vertex gets visited
- Result is not a shortest paths tree for a vertex, but that's OK since we only care about a path to a single vertex

How do we get our estimate?
- Estimate is an arbitrary heuristic h(v, goal)
- heuristic: "using experience to learn and improve"
- Doesn't have to be perfect

Four our version of A* to give the correct answer, out A heuristic must be:
- Admissible: h(v, NYV) <= true distance from v to NYC
- Consistent: For each neighbor of w:
  - h(v, NYV) <= dist(v, w) + h(w, NYC)
  - Where dist(v, w) is the weight of the edge from v to w

All consistent heuristics are admissible
- "Admissible" means that the heuristic never overestimates

Single source, multiple targets:
- Can represent shortest path from start to every vertex as a shortest paths tree with V-1 edges
- Can find the SPT using Dijkstra's algorithm
Single source, single target:
- Dijkstra's is inefficient (searches useless parts of the graph)
- Can represent shortest path as path (with up to V-1 vertices, but probably far fewer)
- A* is potentially much faster than Dijkstra's
  - Consistent heuristic guarantees correct solution