Shortest Path Algorithms

• A source is the starting point of the path.
• A destination is the ending point of a path.
• Shortest Path
  • Given a weighted graph G = (V,E), where each edge has an associated weight
  • Find a path from the destination to the source P = (s, v₁, v₂, ... v_n, e)
  • such that w(s,e) = w(s,v₁) + w(v₁,v₂)+ ...+ w(v_n,e) is minimized.
  • If there is no path from s to e, w(s,e) is inifinitiy
  • Mapquest problem, find the least miles
  • Different weight, fastest route
  • Try Edinboro PA, to Ripley NY
• Several classes of problems
  • Single Source Shortest Path
    • Given a starting point, find the shortest paths to all verticies
  • Single Pair Shortest Path
    • Given a starting point and an Ending point, find the shortest path between the two.
    • There are no known algorithms that solve this asympoticaly faster than SSSP
  • All pairs shortest path
    • Find the shortest path for every pair of verticies u,v in V.
    • For each vertex we could do an SSSP, or perhaps we can do better
• Negative weight edges
  • These are ok only if there are no negative weight cycles
  • That could mean really inexpensive paths by taking the cycle over and over.
  • Some algorithms can't handle negative weight paths either.
• Example:
  • 
  • Multiple SSSP paths exist from v
• The shortest path problem exhibits optimal substructure
  • Prove if P=((s,v₁) + w(v₁,v₂)+ ...+ w(v_n,e) is a shortest path from s to e, then P_i = (s, v₁, v₂, ... v_i) is a shortest path from s to v_i, i <= n.
  • Assume P'_i is a less expensive path from s to v_i, then let P' = P-P_i+P'_i. Clearly this is a less expensive path from s to e, so P is not optimal. This is a contradiction, so P_i must be an optimal path, and the proposition is true.
  • This optimal substructure means this problem is a candidate for a greedy algorithm.
  • And that is what Dijkstra's algorithm is.
• Relaxation
  • The main idea, is at each vertex, keep a cost of the shortest path to this node discovered so far
  • An initialization routing

  • InitializeSingleSource(G,s)
    (1) foreach each vertex v in V
    (2)    v.distance = infinity
    (3)    v.parent = NULL
    (4) v.distance = 0
    	

  • After we discover a node, we want to see if the path through it is a new lower cost, so

  • Relax(u,v,w)
    (1) if v.distance > u.distance + w(u,v)
    (2)     v.distance = u.distance + w(u,v)
    (3)     v.parent = u
        

  • A series of lemmas
    • If G=(V,E) is a weighted directed graph, with weight function w, After relaxing edge(u,v) we have v.distance <= u.distance + w(u,v)
    • Once the distance for an edge reaches its minimum, it will not be changed again.
• Dijkstra's Algorithm

  • Dijkstra(G,w,s)
    (1) Initialize SingleSource(G,s)
    (2) S = NUL  // the set of verticies discovered
    (3) Q=V  // G=(V,E) // Q is a heap
    (4) While !Q.IsEmpty()
    (5)    u = Q.ExtractMin()
    (6)    S = S union {u}
    (7)    foreach v adjacient to u
    (8)      Relax(u,v,w);
    	

  • 
  • Trace with s= v
  • Performance
    • Line 1 is O(|V|)
    • Line 4 is O(|V|)
    • Line 5 is O(lg|V|)
    • Line 7 is O(|E|)
    • Line 8 is O(lg|V|)
    • So it is O((V+E) lg|V|)
• Bellman-Ford
  • Deals with graphs with negative weight edges
  • BUT NO NEGITAVE WEIGHT CYCLES
  • In this algorithm, false is returned if there is a negative weight cycle

  • BellmanFord(G,w,s)
    (1) Initialize SingleSource(G,s)
    (2) for i = 1 to |V| - 1 do
    (3)    for each edge (u,v) in E
    (4)        Relax(u,v,w)
    (5) foreach edge (u,v) in E
    (6)    if v.distance > u.distance + w(u,v)
    (7)       return False
    (8) return True
    	

  • 
  • Again, start at v.
  • Timing
    • Line 1 is O(V)
    • Line 2 is O(V)
    • Line 3 is O(E)
    • Lines 2-3 are O(VE)
    • Line 5 is O(E)
    • The entire thing is O(VE)