Slideshare uses cookies to improve functionality and performance, and to provide you with relevant advertising. If you continue browsing the site, you agree to the use of cookies on this website. See our User Agreement and Privacy Policy.

Slideshare uses cookies to improve functionality and performance, and to provide you with relevant advertising. If you continue browsing the site, you agree to the use of cookies on this website. See our Privacy Policy and User Agreement for details.

Like this presentation? Why not share!

- Snapdeal GOSF 2014 Offers, Coupons ... by GrabOn 209 views
- Classification by Datamining Tools 3051 views
- The game of cops and robbers by Siyoung Oh 1510 views
- Game Programming 13 - Debugging & P... by Nick Prühs 127 views
- Cte harvestworks final by Marco Donnarumma 129 views
- Scrum - but... Agile Game Developme... by Nick Prühs 183 views

3,510 views

Published on

No Downloads

Total views

3,510

On SlideShare

0

From Embeds

0

Number of Embeds

8

Shares

0

Downloads

97

Comments

0

Likes

2

No embeds

No notes for slide

- 1. Implementation of Thorup's Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Implementation of Thorup's Linear Time Integer Weights Nick Prühs Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Introduction Thorup's algorithm Overview Nick Prühs msb-Minimum spanning tree M Component tree T Bucketing structure B Department of Computer Science, CAU Kiel September 30, 2009 Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 2. Implementation of Thorup's Linear Time Algorithm for Undirected Introduction Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 3. Implementation of Thorup's Linear Time Algorithm for Undirected Introduction Single-Source Shortest Paths with Positive Integer Weights Thorup's algorithm Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 4. Implementation of Thorup's Linear Time Algorithm for Undirected Introduction Single-Source Shortest Paths with Positive Integer Weights Thorup's algorithm Nick Prühs Introduction Implementation details Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 5. Implementation of Thorup's Linear Time Algorithm for Undirected Introduction Single-Source Shortest Paths with Positive Integer Weights Thorup's algorithm Nick Prühs Introduction Implementation details Thorup's algorithm Overview Performance msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 6. Implementation of Thorup's Linear Time Algorithm for Undirected Introduction Single-Source Shortest Paths with Positive Integer Weights Thorup's algorithm Nick Prühs Introduction Implementation details Thorup's algorithm Overview Performance msb-Minimum spanning tree M Component tree T Bucketing structure B Conclusion Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 7. Implementation of Thorup's Introduction Linear Time Algorithm for Undirected Single-Source Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Conclusion Performance Conclusion
- 8. Introduction Implementation of Thorup's Linear Time The Single-Source Shortest Paths Problem Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs in: Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 9. Implementation Introduction of Thorup's Linear Time The Single-Source Shortest Paths Problem Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs in: Introduction undirected, connected graph vertices and |E | = m edges G = (V , E ) with |V | = n Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 10. Introduction Implementation of Thorup's Linear Time The Single-Source Shortest Paths Problem Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs in: Introduction undirected, connected graph G = (V , E ) with |V | = n vertices and |E | = m edges positive edge weight function w : V × V → N with ∀(u , v ) ∈ E : w (u , v ) = ∞ / Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 11. Implementation Introduction of Thorup's Linear Time The Single-Source Shortest Paths Problem Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs in: Introduction undirected, connected graph G = (V , E ) with |V | = n vertices and |E | = m edges positive edge weight function w : V × V → N with ∀(u , v ) ∈ E : w (u , v ) = ∞ / distinguished source vertex s∈V Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 12. Implementation Introduction of Thorup's Linear Time The Single-Source Shortest Paths Problem Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs in: Introduction undirected, connected graph G = (V , E ) with |V | = n vertices and |E | = m edges positive edge weight function w : V × V → N with ∀(u , v ) ∈ E : w (u , v ) = ∞ / distinguished source vertex s∈V out: d (v ) = dist (v , s ) for all other vertices v ∈ V {s } Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 13. Introduction Implementation of Thorup's Linear Time Dijkstra's algorithm Algorithm for Undirected proposed by Edsger W. Dijkstra [Dij59] Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 14. Implementation Introduction of Thorup's Linear Time Dijkstra's algorithm Algorithm for Undirected proposed by Edsger W. Dijkstra [Dij59] additional denitions: set of visited vertices S ⊆ V super distance D (v ) ≥ d (v ) for every vertex with D (v ) = d (v ), minu∈S {d (u ) + w (u , v )}, v ∈S v ∈S / Single-Source Shortest Paths with Positive Integer Weights Nick Prühs v ∈ V, Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 15. Implementation Introduction of Thorup's Linear Time Dijkstra's algorithm Algorithm for Undirected proposed by Edsger W. Dijkstra [Dij59] additional denitions: set of visited vertices S ⊆ V super distance D (v ) ≥ d (v ) for every vertex with D (v ) = initialization: d (v ), minu∈S {d (u ) + w (u , v )}, S = {s } D (s ) = d (s ) = 0 ∀v = s : D (v ) = w (s , v ) v ∈S v ∈S / Single-Source Shortest Paths with Positive Integer Weights Nick Prühs v ∈ V, Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 16. Implementation Introduction of Thorup's Linear Time Dijkstra's algorithm Algorithm for Undirected proposed by Edsger W. Dijkstra [Dij59] additional denitions: set of visited vertices S ⊆ V super distance D (v ) ≥ d (v ) for every vertex with D (v ) = d (v ), minu∈S {d (u ) + w (u , v )}, Single-Source Shortest Paths with Positive Integer Weights Nick Prühs v ∈ V, v ∈S v ∈S / initialization: Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T S = {s } D (s ) = d (s ) = 0 ∀v = s : D (v ) = w (s , v ) algorithm: 1. while S = V : Introduction Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation visit the vertex v ∈ S minimizing D (v ) / details Performance Conclusion
- 17. Implementation Introduction of Thorup's Linear Time Dijkstra's algorithm Algorithm for Undirected proposed by Edsger W. Dijkstra [Dij59] additional denitions: set of visited vertices S ⊆ V super distance D (v ) ≥ d (v ) for every vertex with D (v ) = d (v ), minu∈S {d (u ) + w (u , v )}, Single-Source Shortest Paths with Positive Integer Weights Nick Prühs v ∈ V, Introduction v ∈S v ∈S / Thorup's algorithm Overview msb-Minimum spanning tree M initialization: Component tree T S = {s } D (s ) = d (s ) = 0 ∀v = s : D (v ) = w (s , v ) algorithm: 1. while S = V : 1.1 move 1.2 for all v Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation visit the vertex v ∈ S minimizing D (v ) / to S, because (u , v ) ∈ E , the latter is less Performance D (v ) decrease = d (v ) D (u ) to D (v ) + w (u , v ), details Conclusion if
- 18. Introduction Implementation of Thorup's Linear Time The problem: The bottleneck of Dijkstra's algorithm Algorithm for Undirected running time results from two operations: Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 19. Implementation Introduction of Thorup's Linear Time The problem: The bottleneck of Dijkstra's algorithm Algorithm for Undirected running time results from two operations: deleteMin: nd a vertex v ∈ S minimizing / (exactly n − 1 times) Single-Source Shortest Paths D (v ) with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 20. Introduction Implementation of Thorup's Linear Time The problem: The bottleneck of Dijkstra's algorithm Algorithm for Undirected running time results from two operations: deleteMin: nd a vertex v ∈ S minimizing D (v ) / (exactly n − 1 times) decreaseKey: decrease D (u ) (at most m times) Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 21. Introduction Implementation of Thorup's Linear Time The problem: The bottleneck of Dijkstra's algorithm Algorithm for Undirected running time results from two operations: deleteMin: nd a vertex v ∈ S minimizing D (v ) / (exactly n − 1 times) decreaseKey: decrease D (u ) (at most m times) naive implementation: deleteMin in O (n) decreaseKey in O (1) total running time is O (n2 + m) Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 22. Introduction Implementation of Thorup's Linear Time The problem: The bottleneck of Dijkstra's algorithm Algorithm for Undirected running time results from two operations: deleteMin: nd a vertex v ∈ S minimizing D (v ) / (exactly n − 1 times) decreaseKey: decrease D (u ) (at most m times) naive implementation: deleteMin in O (n) decreaseKey in O (1) total running time is O (n2 + m) implementation with Fibonacci heaps [FT84]: deleteMin has amortized running time O (log n) decreaseKey has running time O (1) total running time is O (n log n + m) Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 23. Introduction Implementation of Thorup's Linear Time The problem: The bottleneck of Dijkstra's algorithm Algorithm for Undirected running time results from two operations: deleteMin: nd a vertex v ∈ S minimizing D (v ) / (exactly n − 1 times) decreaseKey: decrease D (u ) (at most m times) naive implementation: deleteMin in O (n) decreaseKey in O (1) total running time is O (n2 + m) implementation with Fibonacci heaps [FT84]: deleteMin has amortized running time O (log n) decreaseKey has running time O (1) total running time is O (n log n + m) linear time Dijkstra requires linear time sorting Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 24. Introduction Implementation of Thorup's Linear Time The problem: The bottleneck of Dijkstra's algorithm Algorithm for Undirected running time results from two operations: deleteMin: nd a vertex v ∈ S minimizing D (v ) / (exactly n − 1 times) decreaseKey: decrease D (u ) (at most m times) naive implementation: deleteMin in O (n) decreaseKey in O (1) total running time is O (n2 + m) implementation with Fibonacci heaps [FT84]: deleteMin has amortized running time O (log n) decreaseKey has running time O (1) total running time is O (n log n + m) linear time Dijkstra requires linear time sorting sorting using comparisons only requires Ω(n log n) comparisons Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 25. Introduction Implementation of Thorup's Linear Time The solution: Avoiding the sorting bottleneck Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 26. Introduction Implementation of Thorup's Linear Time The solution: Avoiding the sorting bottleneck Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Thorup [Tho99] does not visit the vertices in order of increasing distance from s Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 27. Introduction Implementation of Thorup's Linear Time The solution: Avoiding the sorting bottleneck Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Thorup [Tho99] does not visit the vertices in order of increasing distance from s identies vertex pairs that can be visited in any order, using a hierarchical bucketing structure Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 28. Introduction Implementation of Thorup's Linear Time The solution: Avoiding the sorting bottleneck Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Thorup [Tho99] does not visit the vertices in order of increasing distance from s Introduction Thorup's algorithm identies vertex pairs that can be visited in any order, using a hierarchical bucketing structure Overview requires several other data structures to be computed before Bucketing structure B msb-Minimum spanning tree M Component tree T Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 29. Implementation of Thorup's Introduction Linear Time Algorithm for Undirected Single-Source Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Conclusion Performance Conclusion
- 30. Thorup's algorithm Implementation of Thorup's Linear Time Overview Algorithm for Undirected Single-Source Shortest Paths with Positive Thorup's algorithm inherits. . . Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 31. Implementation Thorup's algorithm of Thorup's Linear Time Overview Algorithm for Undirected Single-Source Shortest Paths with Positive Thorup's algorithm inherits. . . . . . the denition of G , V , E , n, Integer Weights m, w , d , s , S and D Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 32. Implementation Thorup's algorithm of Thorup's Linear Time Overview Algorithm for Undirected Single-Source Shortest Paths with Positive Thorup's algorithm inherits. . . . . . the denition of G , V , E , n, . . . the initialization of S and D Integer Weights m, w , d , s , S and D Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 33. Thorup's algorithm Implementation of Thorup's Linear Time Overview Algorithm for Undirected Single-Source Shortest Paths with Positive Thorup's algorithm inherits. . . . . . the denition of G , V , E , n, m, w , d , s , S and D . . . the initialization of S and D . . . visiting a vertex v ∈ V , which might decrease D (u ) for some adjacent vertices u ∈ V and moves v to S Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 34. Thorup's algorithm Implementation of Thorup's Linear Time Overview Algorithm for Undirected Single-Source Shortest Paths with Positive Thorup's algorithm inherits. . . . . . the denition of G , V , E , n, m, w , d , s , S and D . . . the initialization of S and D . . . visiting a vertex v ∈ V , which might decrease D (u ) for some adjacent vertices u ∈ V and moves v to S but Thorup allows visiting a vertex v ∈ S not / minimizing D (v ) Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 35. Thorup's algorithm Implementation of Thorup's Linear Time Overview Algorithm for Undirected Single-Source Shortest Paths with Positive Thorup's algorithm inherits. . . . . . the denition of G , V , E , n, m, w , d , s , S and D . . . the initialization of S and D . . . visiting a vertex v ∈ V , which might decrease D (u ) for some adjacent vertices u ∈ V and moves v to S but Thorup allows visiting a vertex v ∈ S not / minimizing D (v ) in order to identify the next vertex to be visited, the vertices are placed in buckets Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 36. Thorup's algorithm Implementation of Thorup's Linear Time Overview Algorithm for Undirected Single-Source Shortest Paths with Positive Thorup's algorithm inherits. . . . . . the denition of G , V , E , n, m, w , d , s , S and D . . . the initialization of S and D . . . visiting a vertex v ∈ V , which might decrease D (u ) for some adjacent vertices u ∈ V and moves v to S but Thorup allows visiting a vertex v ∈ S not / minimizing D (v ) in order to identify the next vertex to be visited, the vertices are placed in buckets every bucket is associated with a component, a node of the component tree explained later Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 37. Thorup's algorithm Implementation of Thorup's Linear Time The main routine Algorithm for Undirected Single-Source Shortest Paths The whole algorithm can be summarized in top-level pseudo-code as follows: with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 38. Thorup's algorithm Implementation of Thorup's Linear Time The main routine Algorithm for Undirected Single-Source Shortest Paths The whole algorithm can be summarized in top-level pseudo-code as follows: 1. Construct an msb-minimum spanning tree M in O (m). with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 39. Thorup's algorithm Implementation of Thorup's Linear Time The main routine Algorithm for Undirected Single-Source Shortest Paths The whole algorithm can be summarized in top-level pseudo-code as follows: 1. Construct an msb-minimum spanning tree M in O (m). 2. Construct the component tree T in O (m). with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 40. Thorup's algorithm Implementation of Thorup's Linear Time The main routine Algorithm for Undirected Single-Source Shortest Paths The whole algorithm can be summarized in top-level pseudo-code as follows: 1. Construct an msb-minimum spanning tree M in O (m). 2. Construct the component tree T in O (m). 3. Construct the unvisited data structure U in O (n). with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 41. Thorup's algorithm Implementation of Thorup's Linear Time The main routine Algorithm for Undirected Single-Source Shortest Paths The whole algorithm can be summarized in top-level pseudo-code as follows: 1. Construct an msb-minimum spanning tree M in O (m). 2. Construct the component tree T in O (m). 3. Construct the unvisited data structure U in O (n). 4. Set S = {s }. 5. Set D (s ) = 0. 6. For all v ∈ V with v = s : Set D (v ) = w (s , v ). with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 42. Thorup's algorithm Implementation of Thorup's Linear Time The main routine Algorithm for Undirected Single-Source Shortest Paths The whole algorithm can be summarized in top-level pseudo-code as follows: 1. Construct an msb-minimum spanning tree M in O (m). 2. Construct the component tree T in O (m). 3. Construct the unvisited data structure U in O (n). 4. Set S = {s }. 5. Set D (s ) = 0. 6. For all v ∈ V with v = s : Set D (v ) = w (s , v ). 7. Visit the root of the component tree T . 8. Return D . with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 43. Implementation of Thorup's Introduction Linear Time Algorithm for Undirected Single-Source Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Conclusion Performance Conclusion
- 44. Thorup's algorithm Implementation of Thorup's Linear Time Constructing a minimum spanning tree in linear time? Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs construction of a minimum spanning tree is possible in linear time [FW90] Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 45. Thorup's algorithm Implementation of Thorup's Linear Time Constructing a minimum spanning tree in linear time? Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs construction of a minimum spanning tree is possible in linear time [FW90] this requires a priority queue called atomic heap, which requires n 212 20 Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 46. Thorup's algorithm Implementation of Thorup's Linear Time Constructing a minimum spanning tree in linear time? Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs construction of a minimum spanning tree is possible in linear time [FW90] this requires a priority queue called atomic heap, which requires n 212 20 nd a dierent way for today's computers Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 47. Implementation Thorup's algorithm The msb -minimum spanning tree of Thorup's M Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs let msb(x ) = log2 x denote the position of the most signicant bit of x ∈ N Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 48. Implementation Thorup's algorithm The msb -minimum spanning tree of Thorup's M Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs let msb(x ) = log2 x denote the position of the most signicant bit of x ∈ N an msb-minimum spanning tree of a graph G is a spanning tree that is minimal in G where each weight x is replaced by msb(x ) Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 49. Implementation Thorup's algorithm The msb -minimum spanning tree of Thorup's M Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs let msb(x ) = log2 x denote the position of the most signicant bit of x ∈ N an msb-minimum spanning tree of a graph G is a spanning tree that is minimal in G where each weight x is replaced by msb(x ) use such an msb-minimum spanning tree for constructing the component tree Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 50. Implementation Thorup's algorithm An example of an input graph of Thorup's G (n = 11, m = 16) Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 51. Implementation Thorup's algorithm The input graph G after having replaced each weight of Thorup's x by msb (x ) Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 52. Implementation Thorup's algorithm An msb -minimum spanning tree of of Thorup's G Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 53. Implementation Thorup's algorithm How to construct an msb -minimum of Thorup's Linear Time spanning tree Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction 1. sort all edges according to their msb-weights in linear time using simple bucketing Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 54. Implementation Thorup's algorithm How to construct an msb -minimum of Thorup's Linear Time spanning tree Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction 1. sort all edges according to their msb-weights in linear time using simple bucketing 2. compute a minimum spanning tree with Kruskal's algorithm [Kru56], using the pre-sorted edges Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 55. Implementation Thorup's algorithm How to construct an msb -minimum of Thorup's Linear Time spanning tree Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction the clustering is done with Tarjan's union-nd algorithm [Tar75] Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 56. Implementation Thorup's algorithm How to construct an msb -minimum of Thorup's Linear Time spanning tree Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction the clustering is done with Tarjan's union-nd algorithm [Tar75] the use of union with size, and nd with path compression leads to a time bound of O (α(m, n)m) Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 57. Implementation of Thorup's Introduction Linear Time Algorithm for Undirected Single-Source Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Conclusion Performance Conclusion
- 58. Thorup's algorithm Implementation of Thorup's Linear Time The component hierarchy Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights let Gi be the subgraph of G containing all edges e ∈ E with w (e ) 2i Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 59. Thorup's algorithm Implementation of Thorup's Linear Time The component hierarchy Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights let Gi be the subgraph of G containing all edges e ∈ E with w (e ) 2i Level i of Thorup's component hierarchy consists of the components of Gi Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 60. Thorup's algorithm Implementation of Thorup's Linear Time The component hierarchy Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights let Gi be the subgraph of G containing all edges e ∈ E with w (e ) 2i Level i of Thorup's component hierarchy consists of the components of Gi use the msb-minimum spanning tree here Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 61. Thorup's algorithm Implementation of Thorup's Linear Time The component hierarchy Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights let Gi be the subgraph of G containing all edges e ∈ E with w (e ) 2i Level i of Thorup's component hierarchy consists of the components of Gi use the msb-minimum spanning tree here let [v ]i denote the component on level i containing the vertex v ∈ V Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 62. Thorup's algorithm Implementation of Thorup's Linear Time The component hierarchy Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights let Gi be the subgraph of G containing all edges e ∈ E with w (e ) 2i Level i of Thorup's component hierarchy consists of the components of Gi use the msb-minimum spanning tree here let [v ]i denote the component on level i containing the vertex v ∈ V the children of a component [v ]i are all components [w ]i −1 with [w ]i = [v ]i , in other words with w ∈ [v ]i Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 63. Thorup's algorithm Implementation of Thorup's Linear Time The component hierarchy Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights let Gi be the subgraph of G containing all edges e ∈ E with w (e ) 2i Level i of Thorup's component hierarchy consists of the components of Gi use the msb-minimum spanning tree here let [v ]i denote the component on level i containing the vertex v ∈ V the children of a component [v ]i are all components [w ]i −1 with [w ]i = [v ]i , in other words with w ∈ [v ]i [v ]i = [w ]i ⇒ dist (v , w ) ≥ 2i Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 64. Thorup's algorithm The subgraph G4 Implementation of Thorup's Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 65. Thorup's algorithm The component tree T Implementation of Thorup's Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights the component tree T skips all nodes [v ]i = [v ]i −1 : Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 66. Thorup's algorithm The component tree T Implementation of Thorup's Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights the component tree T skips all nodes [v ]i = [v ]i −1 : Every leaf of T is a singleton component [v ]0 = {v }, v ∈ V. Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 67. Thorup's algorithm The component tree T Implementation of Thorup's Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights the component tree T skips all nodes [v ]i = [v ]i −1 : Every leaf of T is a singleton component [v ]0 = {v }, v ∈ V. Every internal node of T is a component [v ]i , v ∈ V , with i 0 and [v ]i −1 [v ]i . Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 68. Thorup's algorithm The component tree T Implementation of Thorup's Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights the component tree T skips all nodes [v ]i = [v ]i −1 : Every leaf of T is a singleton component [v ]0 = {v }, v ∈ V. Every internal node of T is a component [v ]i , v ∈ V , with i 0 and [v ]i −1 [v ]i . The root of T is the node [v ]r = G with r minimized. Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 69. Thorup's algorithm The component tree T Implementation of Thorup's Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights the component tree T skips all nodes [v ]i = [v ]i −1 : Every leaf of T is a singleton component [v ]0 = {v }, v ∈ V. Every internal node of T is a component [v ]i , v ∈ V , with i 0 and [v ]i −1 [v ]i . The root of T is the node [v ]r = G with r minimized. the parent of a node [v ]i is its nearest ancestor in the component hierarchy with at least two children Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 70. Thorup's algorithm The component tree T Implementation of Thorup's Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights the component tree T skips all nodes [v ]i = [v ]i −1 : Every leaf of T is a singleton component [v ]0 = {v }, v ∈ V. Every internal node of T is a component [v ]i , v ∈ V , with i 0 and [v ]i −1 [v ]i . The root of T is the node [v ]r = G with r minimized. the parent of a node [v ]i is its nearest ancestor in the component hierarchy with at least two children T has no nodes with exactly one child ⇒ the total number of nodes is bounded by 2n ∈ O (n) Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 71. Thorup's algorithm The component tree T of G Implementation of Thorup's Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 72. Thorup's algorithm The components of G4 Implementation of Thorup's Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 73. Thorup's algorithm The subgraph G4 Implementation of Thorup's Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 74. Implementation Thorup's algorithm How to construct the component tree of Thorup's T Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs 1. sort the edges of M according to the most signicant bits of their weights Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 75. Implementation Thorup's algorithm How to construct the component tree of Thorup's T Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs 1. sort the edges of M according to the most signicant bits of their weights 2. process the resulting sequence of edges e1 , . . . , en−1 in the following way: For i = 1 to n − 1: Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 76. Implementation Thorup's algorithm How to construct the component tree of Thorup's T Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs 1. sort the edges of M according to the most signicant bits of their weights 2. process the resulting sequence of edges e1 , . . . , en−1 in the following way: For i = 1 to n − 1: 2.1 Let (v , w ) = ei . 2.2 Call union(v , w ). 2.3 If msb(w (ei )) msb(w (ei +1 )): Insert all new components of the union-nd structure into T . Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 77. Implementation Thorup's algorithm How to construct the component tree of Thorup's T Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs using Tarjan's union-nd algorithm [Tar75] again, the running time is O (α(m, n)m) Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 78. Implementation Thorup's algorithm How to construct the component tree of Thorup's T Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs using Tarjan's union-nd algorithm [Tar75] again, the running time is O (α(m, n)m) construction T in linear time is also possible: Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 79. Implementation Thorup's algorithm How to construct the component tree of Thorup's T Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs using Tarjan's union-nd algorithm [Tar75] again, the running time is O (α(m, n)m) construction T in linear time is also possible: requires the tabulation-based union-nd algorithm by Gabow and Tarjan which runs in O (m + n) time [GT85] Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 80. Implementation Thorup's algorithm How to construct the component tree of Thorup's T Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs using Tarjan's union-nd algorithm [Tar75] again, the running time is O (α(m, n)m) construction T in linear time is also possible: requires the tabulation-based union-nd algorithm by Gabow and Tarjan which runs in O (m + n) time [GT85] much more complicated than the one by Tarjan we use the simpler one here Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 81. Implementation of Thorup's Introduction Linear Time Algorithm for Undirected Single-Source Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Conclusion Performance Conclusion
- 82. Thorup's algorithm The bucketing structure B Implementation of Thorup's Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive visit the nodes of the component tree T in the right order Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 83. Thorup's algorithm The bucketing structure B Implementation of Thorup's Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive visit the nodes of the component tree T in the right order whenever a component [v ]i is visited, so are all its ancestors in T Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 84. Thorup's algorithm The bucketing structure B Implementation of Thorup's Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive visit the nodes of the component tree T in the right order whenever a component [v ]i is visited, so are all its ancestors in T bucket the children [w ]h of a component [v ]i into B ([v ]i , min D ([w ]− ) i − 1) h Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 85. Thorup's algorithm The bucketing structure B Implementation of Thorup's Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive visit the nodes of the component tree T in the right order whenever a component [v ]i is visited, so are all its ancestors in T bucket the children [w ]h of a component [v ]i into B ([v ]i , min D ([w ]− ) i − 1) h maintain two additional properties for every component: ix ([v ]i ) ≤ the smallest index of a nonempty bucket of [v ]i ∆([v ]i ) = number buckets of [v ]i Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 86. Thorup's algorithm The bucketing structure B Implementation of Thorup's Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive visit the nodes of the component tree T in the right order whenever a component [v ]i is visited, so are all its ancestors in T bucket the children [w ]h of a component [v ]i into B ([v ]i , min D ([w ]− ) i − 1) h maintain two additional properties for every component: ix ([v ]i ) ≤ the smallest index of a nonempty bucket of [v ]i ∆([v ]i ) = number buckets of [v ]i the total number of buckets is bounded by 8n Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 87. Implementation of Thorup's Introduction Linear Time Algorithm for Undirected Single-Source Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Conclusion Performance Conclusion
- 88. Implementation Thorup's algorithm The unvisited data structure of Thorup's U Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights The unvisited data structure U . . . Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 89. Implementation Thorup's algorithm The unvisited data structure of Thorup's U Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights The unvisited data structure U . . . . . . represents the unvisited subforest of the component tree T Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 90. Implementation Thorup's algorithm The unvisited data structure of Thorup's U Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights The unvisited data structure U . . . . . . represents the unvisited subforest of the component tree T . . . is required for maintaining the changing values min D ([v ]− ) for the changing set of roots [v ]i in the i unvisited part of T in linear total time Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 91. Implementation Thorup's algorithm The unvisited data structure of Thorup's U Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights The unvisited data structure U . . . . . . represents the unvisited subforest of the component tree T . . . is required for maintaining the changing values min D ([v ]− ) for the changing set of roots [v ]i in the i unvisited part of T in linear total time [v ]i is a root of a tree in U if and only if [v ]i is an unvisited child of a visited component in T Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 92. Implementation Thorup's algorithm The unvisited data structure of Thorup's U Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights The unvisited data structure U . . . . . . represents the unvisited subforest of the component tree T . . . is required for maintaining the changing values min D ([v ]− ) for the changing set of roots [v ]i in the i unvisited part of T in linear total time [v ]i is a root of a tree in U if and only if [v ]i is an unvisited child of a visited component in T [v ]i = [v ]i for each of these roots, because they are unvisited − Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 93. Thorup's algorithm Implementation of Thorup's Linear Time The problem: Operations of the unvisited data structure Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs two operations in amortized constant time: 1. Update min D ([v ]i ) whenever D (v ) is decreased for some vertex v ∈ V with unvisited root [v ]i . 2. Turn all children [w ]h of [v ]i in T into roots in U and compute min D ([w ]− ) for all of them whenever an h unvisited root [v ]i is visited. Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 94. Thorup's algorithm Implementation of Thorup's Linear Time The problem: Operations of the unvisited data structure Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs two operations in amortized constant time: 1. Update min D ([v ]i ) whenever D (v ) is decreased for some vertex v ∈ V with unvisited root [v ]i . 2. Turn all children [w ]h of [v ]i in T into roots in U and compute min D ([w ]− ) for all of them whenever an h unvisited root [v ]i is visited. transform this problem into another one that can be solved by the split-ndmin structure by Gabow [Gab85] Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 95. Implementation Thorup's algorithm The initial unvisited data structure of Thorup's U of G Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion [1, 2, 3, 10, 8, 9, 4, 5, 7, 11, 6]
- 96. Implementation Thorup's algorithm The unvisited data structure of Thorup's U after having called visit([1]11 ) Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion [1, 2, 3, 10, 8, 9, 4, 5, 7, 11] [6]
- 97. Implementation Thorup's algorithm The unvisited data structure of Thorup's U after having called visit([1]9 ) Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion [1, 2, 3, 10, 8, 9, 4, 5, 7] [11] [6]
- 98. Implementation Thorup's algorithm The unvisited data structure of Thorup's U after having called visit([1]7 ) Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion [1, 2, 3, 10, 8, 9] [4, 5, 7] [11] [6]
- 99. Thorup's algorithm Implementation of Thorup's Linear Time Total running time of the operations of the unvisited data structure Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights for k ∈ N, k 2, each split in k can be implemented by k − 1 splits in two Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 100. Thorup's algorithm Implementation of Thorup's Linear Time Total running time of the operations of the unvisited data structure Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights for k ∈ N, k 2, each split in k can be implemented by k − 1 splits in two at most n − 1 splits in two, because |V | = n Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 101. Thorup's algorithm Implementation of Thorup's Linear Time Total running time of the operations of the unvisited data structure Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights for k ∈ N, k 2, each split in k can be implemented by k − 1 splits in two at most n − 1 splits in two, because |V | = n at most m decreases, one for each edge in G Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 102. Thorup's algorithm Implementation of Thorup's Linear Time Total running time of the operations of the unvisited data structure Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights for k ∈ N, k 2, each split in k can be implemented by k − 1 splits in two at most n − 1 splits in two, because |V | = n at most m decreases, one for each edge in G Gabow's split-ndmin data structure supports exactly these two operations Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 103. Thorup's algorithm Implementation of Thorup's Linear Time Total running time of the operations of the unvisited data structure Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights for k ∈ N, k 2, each split in k can be implemented by k − 1 splits in two at most n − 1 splits in two, because |V | = n at most m decreases, one for each edge in G Gabow's split-ndmin data structure supports exactly these two operations the total runinng time for n − 1 splits and m decreases is O (α(m, n)m) Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 104. Thorup's algorithm Implementation of Thorup's Linear Time Operations of the unvisited data structure in linear total time? Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Thorup presented an O (m + n) solution [Tho99]), which is based on the atomic heaps by Fredman and Willard Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 105. Thorup's algorithm Implementation of Thorup's Linear Time Operations of the unvisited data structure in linear total time? Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Thorup presented an O (m + n) solution [Tho99]), which is based on the atomic heaps by Fredman and Willard as mentioned above, these priority queues require n 212 20 Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 106. Thorup's algorithm Implementation of Thorup's Linear Time Operations of the unvisited data structure in linear total time? Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Thorup presented an O (m + n) solution [Tho99]), which is based on the atomic heaps by Fredman and Willard Introduction Thorup's algorithm as mentioned above, these priority queues require n 212 Overview fall back to the solution by Gabow and to a total running time of O (α(m, n)m) Bucketing structure B 20 msb-Minimum spanning tree M Component tree T Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 107. Implementation of Thorup's Introduction Linear Time Algorithm for Undirected Single-Source Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Conclusion Performance Conclusion
- 108. Thorup's algorithm Implementation of Thorup's Linear Time The main routine revisited Algorithm for Undirected Single-Source Shortest Paths with Positive 1. Construct an msb-minimum spanning tree M in O (m). Integer Weights Nick Prühs (done) Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 109. Thorup's algorithm Implementation of Thorup's Linear Time The main routine revisited Algorithm for Undirected Single-Source Shortest Paths with Positive 1. Construct an msb-minimum spanning tree M in O (m). Integer Weights Nick Prühs (done) 2. Construct the component tree T in O (m). (done) Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 110. Thorup's algorithm Implementation of Thorup's Linear Time The main routine revisited Algorithm for Undirected Single-Source Shortest Paths with Positive 1. Construct an msb-minimum spanning tree M in O (m). Integer Weights Nick Prühs (done) 2. Construct the component tree T in O (m). (done) 3. Construct the unvisited data structure U in O (n). (done) Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 111. Thorup's algorithm Implementation of Thorup's Linear Time The main routine revisited Algorithm for Undirected Single-Source Shortest Paths with Positive 1. Construct an msb-minimum spanning tree M in O (m). Integer Weights Nick Prühs (done) 2. Construct the component tree T in O (m). (done) 3. Construct the unvisited data structure U in O (n). (done) 4. Set S = {s }. (done) 5. Set D (s ) = 0. (done) 6. For all v ∈ V with v = s : Set D (v ) = w (s , v ). (done) Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 112. Thorup's algorithm Implementation of Thorup's Linear Time The main routine revisited Algorithm for Undirected Single-Source Shortest Paths with Positive 1. Construct an msb-minimum spanning tree M in O (m). Integer Weights Nick Prühs (done) 2. Construct the component tree T in O (m). (done) 3. Construct the unvisited data structure U in O (n). (done) 4. Set S = {s }. (done) 5. Set D (s ) = 0. (done) 6. For all v ∈ V with v = s : Set D (v ) = w (s , v ). (done) 7. Visit the root of the component tree T . 8. Return D . Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 113. Thorup's algorithm Visit( [v ]i ): Implementation of Thorup's Linear Time Step 1 Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction If [v ]i is the root of T , 1. then: Set j = ω + 1. 2. else: Let [v ]j be the parent of [v ]i in T . Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 114. Implementation Thorup's algorithm Visit( [v ]i ): of Thorup's Linear Time Step 2 Algorithm for Undirected Single-Source Shortest Paths with Positive If i = 0: Integer Weights Nick Prühs 1. Add v to S . 2. For all edges (u , v ) ∈ E : 2.1 If D (v ) + w (u , v ) D (w ): 2.1.1 2.1.2 2.1.3 2.1.4 2.1.5 [u ]h be the unvisited root of [u ]0 in U . Let [u ]i be the visited parent of [u ]h in T . − Set oldMin = min D ([u ] ) i − 1. h Decrease D (u ) to D (v ) + w (u , v ). − i − 1 oldMin: Move [u ]h If min D ([u ] ) h B ([u ]i , min D ([u ]h ) i − 1). Introduction Thorup's algorithm Overview Let 3. Remove [v ]i from its bucket of [v ]j . 4. Return. msb-Minimum spanning tree M Component tree T Bucketing structure B to bucket Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 115. Thorup's algorithm Visit( [v ]i ): Implementation of Thorup's Linear Time Step 3 Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs If [v ]i is visited for the rst time: 1. Construct the ∆([v ]i ) buckets of [v ]i . 2. Delete [v ]i from U , turning its children into roots in U . 3. For all children [w ]h of [v ]i : 3.1 Bucket [w ]h in B ([v ]i , min D ([w ]− ) i − 1). h Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 116. Implementation Thorup's algorithm Visit( [v ]i ): of Thorup's Linear Time Steps 4-6 Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Set oldIndex = ix ([v ]i ) j − i. Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 117. Implementation Thorup's algorithm Visit( [v ]i ): of Thorup's Linear Time Steps 4-6 Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Set oldIndex = ix ([v ]i ) j − i. − While [v ]i = ∅ and oldIndex = ix ([v ]i ) 1. While B ([v ]i , ix ([v ]i )) = ∅: 1.1 1.2 [w ]h ∈ B ([v ]i , ix ([v ]i )). Call visit ([w ]h ). Let 2. Increment ix ([v ]i ). Nick Prühs j − i: Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 118. Implementation Thorup's algorithm Visit( [v ]i ): of Thorup's Linear Time Steps 4-6 Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Set oldIndex = ix ([v ]i ) j − i. − While [v ]i = ∅ and oldIndex = ix ([v ]i ) 1. While B ([v ]i , ix ([v ]i )) = ∅: 1.1 1.2 [w ]h ∈ B ([v ]i , ix ([v ]i )). Call visit ([w ]h ). Nick Prühs j − i: Let 2. Increment ix ([v ]i ). If [v ]− = ∅, i 1. then: If [v ]i is not the root of T , remove it from its bucket of [v ]j . 2. else: Move [v ]i to bucket B ([v ]j , ix ([v ]i ) j − i ). Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 119. Implementation of Thorup's Introduction Linear Time Algorithm for Undirected Single-Source Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Conclusion Performance Conclusion
- 120. Implementation details Implementation of Thorup's Linear Time The strategy pattern Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Java implementation: imperative programming language ts the required RAM model object-oriented word length ω = 32, number of vertices n ≤ 232 allows the extensive use of the strategy pattern Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 121. Implementation details Implementation of Thorup's Linear Time Implemented data structures Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs an undirected, weighted graph using adjacency lists an array priority queue Introduction Thorup's algorithm Overview a Fibonacci heap [FT84] msb-Minimum a split-ndmin structure [GT85] T a union-nd structure [Tar75] spanning tree M Component tree Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 122. Implementation details Implementation of Thorup's Linear Time Implemented algorithms Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Kruskal [Kru56] Dijkstra [Dij59] Thorup [Tho99] Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 123. Implementation of Thorup's Introduction Linear Time Algorithm for Undirected Single-Source Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Conclusion Performance Conclusion
- 124. Performance Implementation of Thorup's Linear Time The performance tests Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction average of ve passes Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 125. Performance Implementation of Thorup's Linear Time The performance tests Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction average of ve passes the test system: Intel Core 2 Duo E6300 at 1,86 GHz 2048 MB DDR2 667 PC2-5300 RAM Java 1.6.0_15 Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 126. Performance Implementation of Thorup's Linear Time Varying the number of vertices Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction start with n = 1000 and increase it in steps of 1000 until n = 10000 about m = 5n edges edge weights 1 ≤ w ≤ 100000 Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 127. Performance Implementation of Thorup's Linear Time Varying the number of vertices: Results Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Figure: Running times for 1000 ≤ n ≤ 10000, m = 5n. Performance Conclusion
- 128. Performance Implementation of Thorup's Linear Time Varying the number of vertices Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights start with n = 4000 and increase it in steps of 4000 until n = 40000 about m = 5n edges again edge weights 1 ≤ w ≤ 100000 again Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 129. Performance Implementation of Thorup's Linear Time Varying the number of vertices Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights start with n = 4000 and increase it in steps of 4000 until n = 40000 about m = 5n edges again edge weights 1 ≤ w ≤ 100000 again leave out the naive implementation of Dijkstra's algorithm and focus on the faster one Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 130. Performance Implementation of Thorup's Linear Time Varying the number of vertices Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights start with n = 4000 and increase it in steps of 4000 until n = 40000 about m = 5n edges again edge weights 1 ≤ w ≤ 100000 again leave out the naive implementation of Dijkstra's algorithm and focus on the faster one nd out which n is required for Thorup to catch up with Dijkstra Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 131. Performance Implementation of Thorup's Linear Time Varying the number of vertices: Results Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Figure: Running times for 4000 ≤ n ≤ 40000, m = 5n. Conclusion
- 132. Performance Implementation of Thorup's Linear Time Varying the number of edges per vertex Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction x the number of vertices n = 20000 start with m = 3n edges and increase it in steps of 3n until m = 24n edge weights 1 ≤ w ≤ 100000 again Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 133. Implementation Performance of Thorup's Linear Time Varying the number of edges per vertex: Results Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Figure: Running times for n = 20000, 3n ≤ m ≤ 24n. Conclusion
- 134. Performance Implementation of Thorup's Linear Time Varying the maximum edge weight Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs x the number of vertices n = 20000 x the number of edges m = 5n start by choosing all edge weights 1 ≤ w ≤ 5 and increase the maximum edge weight in steps of 5 until 1 ≤ w ≤ 100 Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 135. Performance Implementation of Thorup's Linear Time Varying the maximum edge weight: Results Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation Figure: Running times for n = 20000, m = 5n, and maximum edge weights between 5 and 100. details Performance Conclusion
- 136. Implementation Performance of Thorup's Linear Time Varying the maximum edge weight: Results Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights maximum edge weight 256 1024 16384 Dijkstra (Fibonacci heap) 212 209 212 219 Thorup (MST) Thorup (other DS) Thorup (visit) 148 153 461 153 171 423 145 156 430 168 140 403 Nick Prühs 262144 Table: Running times for n = 20000, m = 5n and maximum edge weights 28 , 210 , 214 and 218 . Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 137. Performance Implementation of Thorup's Linear Time Repetitive queries Algorithm for Undirected Single-Source Shortest Paths nd out whether Thorup's algorithm can catch up with the one by Dijkstra making repetive queries with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 138. Performance Implementation of Thorup's Linear Time Repetitive queries Algorithm for Undirected Single-Source Shortest Paths nd out whether Thorup's algorithm can catch up with the one by Dijkstra making repetive queries at the rst query, all required data structures are computed once this is the initial lead Dijkstra's algorithm has over the one by Thorup with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 139. Performance Implementation of Thorup's Linear Time Repetitive queries Algorithm for Undirected Single-Source Shortest Paths nd out whether Thorup's algorithm can catch up with the one by Dijkstra making repetive queries at the rst query, all required data structures are computed once this is the initial lead Dijkstra's algorithm has over the one by Thorup clean up between two queries: 1. Reset the set S of visited vertices. 2. Clear all buckets. 3. Reset the unvisited data structure U , making it contain only the root of T . with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 140. Performance Implementation of Thorup's Linear Time Repetitive queries Algorithm for Undirected Single-Source Shortest Paths nd out whether Thorup's algorithm can catch up with the one by Dijkstra making repetive queries at the rst query, all required data structures are computed once this is the initial lead Dijkstra's algorithm has over the one by Thorup clean up between two queries: 1. Reset the set S of visited vertices. 2. Clear all buckets. 3. Reset the unvisited data structure U , making it contain only the root of T . still takes signicantly less time than before the rst query with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 141. Performance Implementation of Thorup's Linear Time Repetitive queries Algorithm for Undirected Single-Source test instance: the road network of New York City number of vertices n = 264, 346 number of edges m = 733, 846 (about m = 3n) Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 142. Performance Implementation of Thorup's Linear Time Repetitive queries Algorithm for Undirected Single-Source test instance: the road network of New York City number of vertices n = 264, 346 number of edges m = 733, 846 (about m = 3n) source: 9th DIMACS Implementation Challenge Shortest Paths [Dem06] Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 143. Performance Implementation of Thorup's Linear Time Repetitive queries Algorithm for Undirected Single-Source test instance: the road network of New York City number of vertices n = 264, 346 number of edges m = 733, 846 (about m = 3n) source: 9th DIMACS Implementation Challenge Shortest Paths [Dem06] Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm nd the shortest paths from the vertices with indices 0 to 9 to all other ones Overview accumulate the resulting running times Bucketing structure B msb-Minimum spanning tree M Component tree T Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 144. Performance Implementation of Thorup's Linear Time Repetitive queries Algorithm for Undirected Single-Source test instance: the road network of New York City number of vertices n = 264, 346 number of edges m = 733, 846 (about m = 3n) source: 9th DIMACS Implementation Challenge Shortest Paths [Dem06] Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm nd the shortest paths from the vertices with indices 0 to 9 to all other ones Overview accumulate the resulting running times Bucketing structure B the initialization of Thorup's algorithm takes about 2100 ms and is added to the rst accumulated time the time required for cleaning up all data structures is always about 200 ms and is added to the accumulated time of the query the clean-up has been done before msb-Minimum spanning tree M Component tree T Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 145. Performance Implementation of Thorup's Linear Time Repetitive queries: Results Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Figure: Accumulated running times for ten queries on the road network of New York City. Performance Conclusion
- 146. Implementation of Thorup's Introduction Linear Time Algorithm for Undirected Single-Source Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Conclusion Performance Conclusion
- 147. Conclusion Implementation of Thorup's Linear Time Algorithm for Undirected Single-Source Thorup's algorithm does not require comparison-based sorting and is today's theoretically fastest SSSP algorithm, . . . Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 148. Conclusion Implementation of Thorup's Linear Time Algorithm for Undirected Single-Source Thorup's algorithm does not require comparison-based sorting and is today's theoretically fastest SSSP algorithm, . . . . . . but our implementation of the algorithm is still signicantly slower than our implementation of Dijkstra's algorithm using a Fibonacci heap Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 149. Conclusion Implementation of Thorup's Linear Time Algorithm for Undirected Single-Source Thorup's algorithm does not require comparison-based sorting and is today's theoretically fastest SSSP algorithm, . . . . . . but our implementation of the algorithm is still signicantly slower than our implementation of Dijkstra's algorithm using a Fibonacci heap possbile reasons are: an inecient implementation a word length which is still too small for realizing the full potential of Thorup's algorithm Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 150. Conclusion Implementation of Thorup's Linear Time Algorithm for Undirected Single-Source Thorup's algorithm does not require comparison-based sorting and is today's theoretically fastest SSSP algorithm, . . . . . . but our implementation of the algorithm is still signicantly slower than our implementation of Dijkstra's algorithm using a Fibonacci heap possbile reasons are: an inecient implementation a word length which is still too small for realizing the full potential of Thorup's algorithm these observations essentially equal the conclusion made by Yasuhito Asano and Hiroshi Imai [AI00] Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 151. Conclusion Implementation of Thorup's Linear Time Future work Algorithm for Undirected Single-Source Shortest Paths implement the strictly linear time parts of Thorup's algorithm: the linear time algorithm for constructing minimum spanning trees [FW90] the linear time union-nd [GT85] structure the linear time split-ndmin structure [Tho99] with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 152. Conclusion Implementation of Thorup's Linear Time Future work Algorithm for Undirected Single-Source Shortest Paths implement the strictly linear time parts of Thorup's algorithm: the linear time algorithm for constructing minimum spanning trees [FW90] the linear time union-nd [GT85] structure the linear time split-ndmin structure [Tho99] see how well Thorup's algorithm does compared to fast all shortest paths algorithms with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 153. Conclusion Implementation of Thorup's Linear Time Future work Algorithm for Undirected Single-Source Shortest Paths implement the strictly linear time parts of Thorup's algorithm: the linear time algorithm for constructing minimum spanning trees [FW90] the linear time union-nd [GT85] structure the linear time split-ndmin structure [Tho99] see how well Thorup's algorithm does compared to fast all shortest paths algorithms see if his component tree can be useful for other applications with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 154. Conclusion Implementation of Thorup's Linear Time Future work Algorithm for Undirected Single-Source Shortest Paths implement the strictly linear time parts of Thorup's algorithm: the linear time algorithm for constructing minimum spanning trees [FW90] the linear time union-nd [GT85] structure the linear time split-ndmin structure [Tho99] see how well Thorup's algorithm does compared to fast all shortest paths algorithms see if his component tree can be useful for other applications run the algorithm on signicantly larger graphs and check whether it is as attractive for repetitive queries as expected, as soon as we are able to with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 155. Conclusion Implementation of Thorup's Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Thank you for your attention! Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 156. Yasuhito Asano and Hiroshi Imai. Practical eciency of the linear-time algorithm for the single source shortest path problem. Journal of the Operations Research, 43:431447, 2000. Camil Demetrescu. 9th dimacs implementation challenge - shortest paths. http://www.dis.uniroma1.it/~challenge9/ download.shtml, 2006. Edsger W. Dijkstra. A note on two problems in connection with graphs. Numer. Math., 1:269271, 1959. Michael L. Fredman and Robert Endre Tarjan. Fibonacci heaps and their uses in improved network optimization algorithms. In FOCS, pages 338346. IEEE, 1984. Michael L. Fredman and Dan E. Willard. Implementation of Thorup's Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 157. Trans-dichotomous algorithms for minimum spanning trees and shortest paths. In FOCS, volume II, pages 719725. IEEE, 1990. Harold N. Gabow. A scaling algorithm for weighted matching on general graphs. In FOCS, pages 90100. IEEE, 1985. Harold N. Gabow and Robert Endre Tarjan. A linear-time algorithm for a special case of disjoint set union. J. Comput. Syst. Sci., 30(2):209221, 1985. Joseph B. Kruskal. On the shortest spanning subtree of a graph and the traveling salesman problem. Proc. Am. Math. Soc, 7:4850, 1956. Robert Endre Tarjan. Eciency of a good but not linear set union algorithm. J. ACM, 22(2):215225, 1975. Implementation of Thorup's Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion
- 158. Mikkel Thorup. Undirected single-source shortest paths with positive integer weights in linear time. J. ACM, 46(3):362394, 1999. Implementation of Thorup's Linear Time Algorithm for Undirected Single-Source Shortest Paths with Positive Integer Weights Nick Prühs Introduction Thorup's algorithm Overview msb-Minimum spanning tree M Component tree T Bucketing structure B Unvisited data structure U Visiting components and vertices Implementation details Performance Conclusion

No public clipboards found for this slide

×
### Save the most important slides with Clipping

Clipping is a handy way to collect and organize the most important slides from a presentation. You can keep your great finds in clipboards organized around topics.

Be the first to comment