1. 1 Paths in Graphs Oscar Miguel Alonso M

2. 2 Outline The problem to be solved Breadth first search Dijkstra's Algorithm Bellman-Ford Algorithm Shortest path in DAGs Efficient implementation of Dijkstra (Heap) Bonus: graph diameter, all to all shortest path (Floyd algorithm)

3. 3 Paths in graphs Find the shortest path between two nodes  Are all the edges of the same cost?  Are there edges with negative cost?  Is the graph directed?  Are there cycles of negative cost? Given a graph, which are the most distant nodes?

4. 4 Breadth first search Idea:  You begin with one node S  Then, visit all the nodes at distance 1 from S  Then, visit the all nodes at distance 2 from S  You continue until you meet your target node or you have reached all the nodes

5. 5 s Breadth first search

6. 6 s 1 1 1

7. 7 s 1 1 1 2

8. 8 BFS(G,s) Input: Graph G=(V,E), node s Output: array dist[] // dist[u] is the distance from s to u Vars: Queue Q for-each u in V dist[u]=∞ dist [s]=0 Q.add(s) while(!Q.empty()) u = Q.get() for-each edge ( u, v ) in E if dist[v]==∞ Q.add(v) dist[v]=dist[u]+1 O(E)

9. 9 s Breadth first search Application of the algorithm: see whiteboard 0 1 3 2 4

10. 10 Dijkstra's algorithm Edge Relaxation  if(dist[u] > dist[k]+W[k][u]) dist[u] = dist[k]+W[k][u] Used in weighted graphs Do not use it if there are negative weighs!

11. 11 Dijkstra's algorithm Idea:  Keep a list of nodes which you already know the shortest path to  Such list begin with only one node (s), and you add one node in each iteration of the algorithm  The node added is connected to one node in the list, and is the one with minimum distance to the origin from all candidates

12. 12 0 3 1 3 1 3 2 3 Dijkstra's algorithm 0 1 2 3 4

13. 13 0 2 3 1 3 1 3 2 3 Dijkstra's algorithm 0 1 2 3 4

14. 14 0 3 2 3 1 3 1 3 2 3 Dijkstra's algorithm 0 1 2 3 4

15. 15 0 3 3 2 4 3 1 3 1 3 2 3 Dijkstra's algorithm 0 1 2 3 4

16. 16 Dijkstra's algorithm For the implementation  Keep an array indicating the minimum distance so far to each node (initialize with infinite)  Update the distance each time you add a node (relax the edges from that node)  Keep a list of the nodes not reached, instead of the ones reached  Now, instead of searching the node with minimum distance, just pick the one with lower distance

17. 17 ∞ ∞ ∞ ∞ ∞ 3 1 3 1 3 2 3 Dijkstra's algorithm 0 1 2 3 4

18. 18 0 3 3 2 ∞ 3 1 3 1 3 2 3 Dijkstra's algorithm 0 1 2 3 4

19. 19 0 3 3 2 5 3 1 3 1 3 2 3 Dijkstra's algorithm 0 1 2 3 4

20. 20 0 3 3 2 4 3 1 3 1 3 2 3 Dijkstra's algorithm 0 1 2 3 4

21. 21 0 3 3 2 4 3 1 3 1 3 2 3 Dijkstra's algorithm 0 1 2 3 4

22. 22 0 3 3 2 4 3 1 3 1 3 2 3 Dijkstra's algorithm 0 1 2 3 4

23. 23 Dijkstra's algorithm DIJKSTRA(G,s) for-each i in V d[ i ] ← ∞ Q.add(i) d[s] ← 0 while not empty(queue) do u = Q.extract_min() // take node with minimum dist for-each v where (u, v) in E if d[v] > d[u] + w uv then d[v] = d[u] + w uv Note that d[v] represents the known shortest distance of v from s during the process and may not be the real shortest distance until v is marked black.

24. 24 Dijkstra's algorithm Complexity:  Depends on Queue implementation E lg VVHeap E lg VEHeap (Lazy) VEEArray (Lazy) VEVSorted Array E + V lg VVFibonacci Heap V2V2 VArray TimeMemoryWorst Case Big-Oh

25. 25 Bellman-Ford algorithm Useful when there are negative-weighted edges Idea: relax all the edges n times A path can be found with max n-i edge relaxations If after that, the graph allow other edge relaxation, the graph has a negative weight cycle 5 -3

26. 26 Bellman-Ford algorithm Do n-1 times for-each (u, v) in E if d[v] > d[u] + w uv then d[v] ← d[u] + w uv Complexity = O(VE)

27. 27 Shortest path in DAGs In DAGs the problem is easier Idea: sort the nodes (topological sort), and traverse the nodes, relaxing all their edges ShortestPath-DAG(G,s) for-each i in V d[ i ] ← ∞ d[s] ← 0 TS = TopologicalSort(G) for-each u in TS for-each v where (u, v) is and edge if d[v] > d[u] + w uv then d[v] = d[u] + w uv O(E)

28. 28 Shortest path in DAGs

29. 29 Heap data structure A heap is a comlete binary tree in which every parent is greater (smaller) than its child(ren). extract-min and decrease-key operations are performed in O(log(n)) constructed in O(n) stored efficiently in an array:  no need for pointers  parent of element i is in pos (i-1)/2  left son is in pos 2*i+1  left son is in pos 2*i+2 31 87 67 54 1927

30. 30 Heap data structure 31 87 67 54 1927 31 87 67 54 19 27

31. 31 Heap data structure Example: extract-min

32. 32 Heap data structure

33. 33 Heap data structure

34. 34 Heap data structure

35. 35 Warshall-Floyd Algorithm All to all shortest path d[i][j] is the minimum distance from vertex i to vertex j the diameter of the graph is the maximum d[i][j] after the execution of the algorithm

36. 36 Warshall-Floyd Algorithm Floyd(G) for-each (u, v) in E d[u][v] ← w uv for-each k in V for-each i in V for-each j in V if d[i][j] > d[i][k] + d[k][j] d[i][j] ← d[i][k] + d[k][j] Time Complexity: O(V 3 )

37. 37 THANK YOU !!