![Review: Relaxation Key technique: relaxation Maintain upper bound d[ v ] on (s,v): Relax(u,v,w) { if (d[v] > d[u]+w) then d[v]=d[u]+w; } 9 5 2 7 5 2 Relax 6 5 2 6 5 2 Relax](https://image.slidesharecdn.com/21-1224487910206310-9/85/lecture-21-4-320.jpg)
![Review: Bellman-Ford Algorithm BellmanFord() for each v V d[v] = ; d[s] = 0; for i=1 to |V|-1 for each edge (u,v) E Relax(u,v, w(u,v)); for each edge (u,v) E if (d[v] > d[u] + w(u,v)) return “no solution”; Relax(u,v,w): if (d[v] > d[u]+w) then d[v]=d[u]+w Initialize d[], which will converge to shortest-path value Relaxation: Make |V|-1 passes, relaxing each edge Test for solution: have we converged yet? Ie, negative cycle?](https://image.slidesharecdn.com/21-1224487910206310-9/85/lecture-21-5-320.jpg)
![Review: Bellman-Ford Algorithm BellmanFord() for each v V d[v] = ; d[s] = 0; for i=1 to |V|-1 for each edge (u,v) E Relax(u,v, w(u,v)); for each edge (u,v) E if (d[v] > d[u] + w(u,v)) return “no solution”; Relax(u,v,w): if (d[v] > d[u]+w) then d[v]=d[u]+w What will be the running time?](https://image.slidesharecdn.com/21-1224487910206310-9/85/lecture-21-6-320.jpg)
![Dijkstra’s Algorithm If no negative edge weights, we can beat BF Similar to breadth-first search Grow a tree gradually, advancing from vertices taken from a queue Also similar to Prim’s algorithm for MST Use a priority queue keyed on d[v]](https://image.slidesharecdn.com/21-1224487910206310-9/85/lecture-21-9-320.jpg)
![Dijkstra’s Algorithm Dijkstra(G) for each v V d[v] = ; d[s] = 0; S = ; Q = V; while (Q ) u = ExtractMin(Q); S = S U {u}; for each v u->Adj[] if (d[v] > d[u]+w(u,v)) d[v] = d[u]+w(u,v); Relaxation Step Note: this is really a call to Q->DecreaseKey() B C D A 10 4 3 2 1 5 Ex: run the algorithm](https://image.slidesharecdn.com/21-1224487910206310-9/85/lecture-21-10-320.jpg)
lecture 21
- 1. CS 332: Algorithms S-S Shortest Path: Dijkstra’s Algorithm Disjoint-Set Union Amortized Analysis
- 2. Review: Single-Source Shortest Path Problem: given a weighted directed graph G, find the minimum-weight path from a given source vertex s to another vertex v “Shortest-path” = minimum weight Weight of path is sum of edges E.g., a road map: what is the shortest path from Chapel Hill to Charlottesville?
- 3. Review: Shortest Path Properties Optimal substructure : the shortest path consists of shortest subpaths Let (u,v) be the weight of the shortest path from u to v. Shortest paths satisfy the triangle inequality : (u,v) (u,x) + (x,v) In graphs with negative weight cycles, some shortest paths will not exist
- 4. Review: Relaxation Key technique: relaxation Maintain upper bound d[ v ] on (s,v): Relax(u,v,w) { if (d[v] > d[u]+w) then d[v]=d[u]+w; } 9 5 2 7 5 2 Relax 6 5 2 6 5 2 Relax
- 5. Review: Bellman-Ford Algorithm BellmanFord() for each v V d[v] = ; d[s] = 0; for i=1 to |V|-1 for each edge (u,v) E Relax(u,v, w(u,v)); for each edge (u,v) E if (d[v] > d[u] + w(u,v)) return “no solution”; Relax(u,v,w): if (d[v] > d[u]+w) then d[v]=d[u]+w Initialize d[], which will converge to shortest-path value Relaxation: Make |V|-1 passes, relaxing each edge Test for solution: have we converged yet? Ie, negative cycle?
- 6. Review: Bellman-Ford Algorithm BellmanFord() for each v V d[v] = ; d[s] = 0; for i=1 to |V|-1 for each edge (u,v) E Relax(u,v, w(u,v)); for each edge (u,v) E if (d[v] > d[u] + w(u,v)) return “no solution”; Relax(u,v,w): if (d[v] > d[u]+w) then d[v]=d[u]+w What will be the running time?
- 7. Review: Bellman-Ford Running time: O(VE) Not so good for large dense graphs But a very practical algorithm in many ways Note that order in which edges are processed affects how quickly it converges (show example)
- 8. DAG Shortest Paths Problem: finding shortest paths in DAG Bellman-Ford takes O(VE) time. How can we do better? Idea: use topological sort. How does it work again? If were lucky and processes vertices on each shortest path from left to right, would be done in one pass Every path in a dag is subsequence of topologically sorted vertex order, so processing verts in that order, we will do each path in forward order (will never relax edges out of vert before doing all edges into vert). Thus: just one pass. What will be the running time?
- 9. Dijkstra’s Algorithm If no negative edge weights, we can beat BF Similar to breadth-first search Grow a tree gradually, advancing from vertices taken from a queue Also similar to Prim’s algorithm for MST Use a priority queue keyed on d[v]
- 10. Dijkstra’s Algorithm Dijkstra(G) for each v V d[v] = ; d[s] = 0; S = ; Q = V; while (Q ) u = ExtractMin(Q); S = S U {u}; for each v u->Adj[] if (d[v] > d[u]+w(u,v)) d[v] = d[u]+w(u,v); Relaxation Step Note: this is really a call to Q->DecreaseKey() B C D A 10 4 3 2 1 5 Ex: run the algorithm
- 11. The End