1. Nondecreasing Paths in Weighted Graphs Or: How to optimally read a train schedule Virginia Vassilevska Carnegie Mellon UniversitySODA 2008

2. Traveling? Tomorrow after 8amAs early as possible!

3. Routes with Multiple Stops Chicago BWI 4pm – 8:30pm 1:30pm – 6:00pm 11:40pm – 1:25am 7:00pm – 8:45pm Los Angeles Las Vegas 8:35am – 11am 1:30pm – 4pm 5:05pm – 9:35pm 10:35pm – 12:35am

4. Scheduling You might need to make several connections. There are multiple possible stopover points, and multiple possible schedules. How do you choose which segments to combine?

5. arrival time weight;(Origin, flight) edges;(flight, Destination) edges;departure time weight;Nondecreasing path with minimum last edge? 12pm 9:35pm 11am 5pm4pm 8:45pm 7pm 9:30pm 10:35pm A vertex for each flight;A vertex for each city/airport; Graph-Theoretic Abstraction Chicago 4pm 1:30pm 11:40pm 7pm Los AngelesLas Vegas 8:35am 1:30pm 5:05pm 10:35pm BWI 8:30pm 6pm 12:35am 1:25am … … … … Graph:

6. Versions of the problem Single source – single destination Single source (every destination) All pairs ST All pairs – APNP Single source (every destination) – SSNP

7. History G. Minty 1958: graph abstraction and first algorithm for SSNP E. F. Moore 1959: a new algorithm for shortest paths, and SSNP – polytime – cubic time

8. History Dijkstra 1959 Fredman and Tarjan 1987 – Fibonacci Heaps implementation of Dijkstra’s; until now asymptotically fastest algorithm for SSNP. Nowadays – experimental research on improving Dijkstra’s algorithm implementation O(m+n log n) m – number of edges n – number of vertices

9. Our contributions Linear time algorithm for SSNP in the word-RAM model, O(m log log n) in comparison based model First truly subcubic algorithm for APNP

10. Talk Outline SSNP:  Two known algorithms  A new O(m log log n) algorithm  Linear time algorithm (on a RAM) APNP:  Brief outline of our approach

11. SSNP - Dijkstra’s algorithm Set U = V and T = { }. At each iteration, pick u from U minimizing d[u]. T = T U {u}, U = U \ {u}. For all edges (u, v),  If w(u,v) ≥ d[u], set d[v] = min (d[v], w(u,v)) u T U min d[u] d[u] v w(u,v) S Iterate:

12. Running time of Dijkstra Using Fibonacci Heaps, Dijkstra can be implemented in O(m+n log n) time. Optimal for Dijkstra’s algorithm – nodes visited in sorted order of their distance. The bottleneck are the n extract-mins.

13. More on Dijkstra’s Suppose we only maintain F vertices in the Fibonacci heaps. The rest we maintain in some other way. Then the runtime due to the Fibonacci heaps would be O(F log F + N(F)) where N(F) is the number of edges pointing to the F vertices. For F = m/log n, this is O(m)! F N(F)

14. ALG2: Depth First Search - Like DFS(v, d[v]): For all (v, u) with w(v, u) ≥ d[v]: Remove (v, u) from graph. d[u] = min (d[u], w(v,u)) DFS(u, d[u]) d[S] = - ∞, start with DFS(S, d[S]). v d[v]=2 3 3 1 u d[u]=4d[u]=3

15. Naive Runtime of DFS The number of times we call DFS(v, d[v]) for any particular v is at most indegree(v). Every such time we might have to check all outedges (w(v,u)≥ ? d[v]). Worst case running time: O(mn).

16. More on DFS Suppose for a node v and weight d[v] we can access each edge (v, u) with w(v, u)≥ d[v] in O(t) time. As each edge is accessed at most once, the runtime is O(m t). For each node, store its neighbors in a binary search tree w.r.t. outgoing weights. O(m log n) runtime

17. Combine Dijkstra with DFS Recall:  If F nodes used in Fibonacci heaps, then the Dijkstra runtime due to the heaps is O(F log F + N(F))  If DFS with binary search trees is run on a set of nodes T, the runtime is O(Σ v  T { deg in (v) log (deg out (v)) }) O(m log log n) for T = {v | deg out (v)<log n} ◄ O(m+n) for F = m/log n Low Degree High Degree {v | deg out (v) ≥ log n}

18. Idea Summary Run DFS on vertices of low degree < log n: O(m log log n) time. Put the O(m/log n) high degree nodes in Fibonacci heaps and run Dijkstra on them. Time due to Fibonacci heaps: O(m). We get O(m log log n). Better than O(m+n log n) for m = o(n log n/log log n).

19. But we wanted linear time… Fredman and Willard atomic heaps: After O(n) preprocessing, a collection of O(n) sets of O(log n) size can be maintained so that the following are in constant time:  Insert  Delete  Given w, return an element of weight ≥ w. outedges of low degree vertices RAM

20. Linear runtime Replace binary trees by atomic heaps. Time due to Dijkstra with Fibonacci Heaps on O(m/log n) elements is still O(m). Time due to DFS with atomic heaps:  inserting outedges into atomic heaps takes constant time per edge;  given d[v], accessing an edge with w(v,u) ≥ d[v] takes constant time. O(m+n) time overall! But how do we combine Dijkstra and DFS?

21. Linear Time Algorithm Stage 1: Initialize  Find all vertices v of degree ≥ log n and insert into Fibonacci Heaps with d[v] = ∞;  For all vertices u of degree < log n, add outedges into atomic heap sorted by weights.  This stage takes O(m+n) time. Insert S with d[S] = - ∞

22. 22 Linear Time Algorithm Cont. Stage 2: Repeat: 1. Extract vertex v from Fibonacci heaps with minimum d[v] 2. For all neighbors u of v, if w(u,v) ≥ d[v]: 1. Update d[u] if w(v,u) < d[u] 2. Run DFS(u, d[u]) on the graph spanned by low degree vertices until no more can be reached 3. If Fib.heaps nonempty, go to 1. 3 Fibonacci Heaps 4 5 1 4 4 3

23. (min, ≤ )-matrix product C = A B: C[i, j] = min k { B[k, j] | A[i, k] ≤ B[k, j] } (( W W) W) … W) - min nondecreasing k times All Pairs Nondecreasing Paths (APNP) paths of length ≤ k 7 4 09 45 ij AB Say W is the adjacency matrix: W[i, i] = -  and W[i,j] = w(i, j) for i ≠ j.

24. All Pairs Nondecreasing Paths cont. We give an algorithm for (min, ≤ )- product of n x n matrices running in O(n 2.8 ) time. Hence, APNP for paths of length at most k can be done in O(k n 2.8 ) time. We show how to find APNP for paths of length at least k in Õ(n 3 / k) time. → O(n 2.9 ) Algorithm for APNP.

25. Summary We gave the first linear time algorithm for the single source nondecreasing paths problem, and the first subcubic algorithm for APNP. Now you can read a train schedule optimally!

26. Single source shortest paths?  Our degree approach fails – finding a linear time algorithm is hardest on low degree graphs Shortest Nondecreasing Paths? d … … d’ … … … d … w1w1 wdwd w’ 1 w’ d’ wdwd w1w1 0 0 0 0 Directions for future work o(m log n)?

27. THANK YOU! The End.

29. Example S P Q a b c d 1 2 3 4 5 2 2 2 3 3 3 3 U - Fibonacci Heap: S: -infinity P: infinity Q: infinity Other Distances: a: infinity b: infinity c: infinity d: infinity 5

30. S P Q a b c d 1 2 3 4 5 2 2 2 3 3 3 3 U - Fibonacci Heap: P: infinity Q: infinity Other Distances: a: 5 b: 1 c: 3 d: infinity S: -infinity S – extract min from U 5 Example

31. S P Q a b c d 1 2 3 4 5 2 2 2 3 3 3 3 U - Fibonacci Heap: P: 2 Q: infinity Other Distances: a: 5 b: 1 c: 3 d: infinity S: -infinity DFS(b, 1) 5 Example

32. DFS(a, 5) S P Q a b c d 1 2 3 4 5 2 2 2 3 3 3 3 U - Fibonacci Heap: P: 2 Q: infinity Other Distances: a: 5 b: 1 c: 3 d: infinity S: -infinity DFS(c, 3) 3 5 Example

33. 2 3 P – extract min from U S P Q a b c d 1 2 3 4 5 2 2 3 3 3 U - Fibonacci Heap: Q: 3 Other Distances: a: 3 b: 1 c: 3 d: 2 S: -infinity P: 2 5 Example

34. 2 3 S P Q a b c d 1 2 3 4 5 2 2 3 3 3 U - Fibonacci Heap: Q: 3 Other Distances: a: 2 b: 1 c: 3 d: 2 S: -infinity P: 2 DFS(d, 2) 5 Example

35. 2 3 S P Q a b c d 1 2 3 4 5 2 2 3 3 3 U - Fibonacci Heap: Q: 3 Other Distances: a: 2 b: 1 c: 2 d: 2 S: -infinity P: 2 DFS(a, 2) 5 Example

36. 2 3 S P Q a b c d 1 2 3 4 5 2 2 3 3 3 U - Fibonacci Heap: Q: 3 Other Distances: a: 2 b: 1 c: 2 d: 2 S: -infinity P: 2 DFS(c, 2) 5 DFS(a, 3) Example

37. 2 3 S P Q a b c d 1 2 3 4 5 2 2 3 3 3 U - Fibonacci Heap: Other Distances: a: 2 b: 1 c: 2 d: 2 S: -infinity P: 2 Q: 3 5 Q – extract min from U Example

40. DFS Algorithm

41. Dijkstra Algorithm

42. A linear time hybrid

43. New York Atlanta Newark London Paris Frankfurt 7pm – 1:20pm 11:35pm – 1pm 5:30pm – 10:40am 7:45pm – 8:30pm 11:40am – 4:15pm

44. ∞∞

47. Graph-Theoretic Abstraction City vertices and Train vertices Edges between origin and train and train and destination Weight on origin -> train edge is departure time Weight on train -> destination edge is arrival time

48. Fibonacci Heaps  Inserting n vertices initially takes O(n) time.  Updating the distance d[v] of a vertex v takes constant time.  Returning the vertex u minimizing d[u] takes logarithmic time.