Results 1  10
of
14
Computing PointtoPoint Shortest Paths from External Memory
"... We study the ALT algorithm [19] for the pointtopoint shortest path problem in the context of road networks. We suggest improvements to the algorithm itself and to its preprocessing stage. We also develop a memoryefficient implementation of the algorithm that runs on a Pocket PC. It stores graph d ..."
Abstract

Cited by 56 (6 self)
 Add to MetaCart
We study the ALT algorithm [19] for the pointtopoint shortest path problem in the context of road networks. We suggest improvements to the algorithm itself and to its preprocessing stage. We also develop a memoryefficient implementation of the algorithm that runs on a Pocket PC. It stores graph data in a flash memory card and uses RAM to store information only for the part of the graph visited by the current shortest path computation. The implementation works even on very large graphs, including that of the North America road network, with almost 30 million vertices.
CacheOblivious Data Structures and Algorithms for Undirected BreadthFirst Search and Shortest Paths
 IN PROCEEDINGS OF THE 9TH SCANDINAVIAN WORKSHOP ON ALGORITHM THEORY
, 2004
"... We present improved cacheoblivious data structures and algorithms for breadthfirst search and the singlesource shortest path problem on undirected graphs with nonnegative edge weights. Our results close the performance gap between the currently best cacheaware algorithms for these problems and ..."
Abstract

Cited by 22 (8 self)
 Add to MetaCart
(Show Context)
We present improved cacheoblivious data structures and algorithms for breadthfirst search and the singlesource shortest path problem on undirected graphs with nonnegative edge weights. Our results close the performance gap between the currently best cacheaware algorithms for these problems and their cacheoblivious counterparts. Our shortestpath algorithm relies on a new data structure, called bucket heap, which is the first cacheoblivious priority queue to efficiently support a weak DecreaseKey operation.
Efficient Processing of Distance Queries in Large Graphs: A Vertex Cover Approach
, 2012
"... We propose a novel diskbased index for processing singlesource shortest path or distance queries. The index is useful in a wide range of important applications (e.g., network analysis, routing planning, etc.). Our index is a treestructured index constructed based on the concept of vertex cover. W ..."
Abstract

Cited by 13 (4 self)
 Add to MetaCart
(Show Context)
We propose a novel diskbased index for processing singlesource shortest path or distance queries. The index is useful in a wide range of important applications (e.g., network analysis, routing planning, etc.). Our index is a treestructured index constructed based on the concept of vertex cover. We propose an I/Oefficient algorithm to construct the index when the input graph is too large to fit in main memory. We give detailed analysis of I/O and CPU complexity for both index construction and query processing, and verify the efficiency of our index for query processing in massive realworld graphs.
ISLABEL: an IndependentSet based Labeling Scheme for PointtoPoint Distance Querying
"... We study the problem of computing shortest path or distance between two query vertices in a graph, which has numerous important applications. Quite a number of indexes have been proposed to answer such distance queries. However, all of these indexes can only process graphs of size barely up to 1 mil ..."
Abstract

Cited by 7 (2 self)
 Add to MetaCart
(Show Context)
We study the problem of computing shortest path or distance between two query vertices in a graph, which has numerous important applications. Quite a number of indexes have been proposed to answer such distance queries. However, all of these indexes can only process graphs of size barely up to 1 million vertices, which is rather small in view of many of the fastgrowing realworld graphs today such as social networks and Web graphs. We propose an efficient index, which is a novel labeling scheme based on the independent set of a graph. We show that our method can handle graphs of size orders of magnitude larger than existing indexes. 1.
ExternalMemory Exact and Approximate AllPairs ShortestPaths in Undirected Graphs
, 2004
"... We present several new externalmemory algorithms for finding allpairs shortest paths in a Vnode, Eedge undirected graph. For allpairs shortest paths and diameter in unweighted undirected graphs we present cacheoblivious algorithnls with O(V. ~ log. ~ ~) I/Os, where B is the blocksize and M is ..."
Abstract

Cited by 6 (1 self)
 Add to MetaCart
(Show Context)
We present several new externalmemory algorithms for finding allpairs shortest paths in a Vnode, Eedge undirected graph. For allpairs shortest paths and diameter in unweighted undirected graphs we present cacheoblivious algorithnls with O(V. ~ log. ~ ~) I/Os, where B is the blocksize and M is the size of internal memory. For weighted tmdirected graphs we present a cacheaware APSP algorithm that performs O(V. ( V/ ~ + ~ log ~)) I/Os. We also present efficient cacheaware algorithms that find paths between all pairs of vertices in an unweighted graph with lengths within a small additive constant of the shortest path length. All of our results improve earlier results known for these problems. For approximate APSP we provide the first nontrivial results. Our diameter result uses C9(V + E) extra space, and all of our other algorithms use O(V 2) space.
Design and Implementation of a Practical I/Oefficient Shortest Paths Algorithm
"... We report on initial experimental results for a practical I/Oefficient SingleSource ShortestPaths (SSSP) algorithm on general undirected sparse graphs where the ratio between the largest and the smallest edge weight is reasonably bounded (for example integer weights in {1,...,2 32}) and the reali ..."
Abstract

Cited by 4 (1 self)
 Add to MetaCart
(Show Context)
We report on initial experimental results for a practical I/Oefficient SingleSource ShortestPaths (SSSP) algorithm on general undirected sparse graphs where the ratio between the largest and the smallest edge weight is reasonably bounded (for example integer weights in {1,...,2 32}) and the realistic assumption holds that main memory is big enough to keep one bit per vertex. While our implementation only guarantees averagecase efficiency, i.e., assuming randomly chosen edgeweights, it turns out that its performance on realworld instances with nonrandom edge weights is actually even better than on the respective inputs with random weights. Furthermore, compared to the currently best implementation for externalmemory BFS [6], which in a sense constitutes a lower bound for SSSP, the running time of our approach always stayed within a factor of five, for the most difficult graph classes the difference was even less than a factor of two. We are not aware of any previous I/Oefficient implementation for the classic general SSSP in a (semi) external setting: in two recent projects [10, 23], Kumar/Schwabelike SSSP approaches on graphs of at most 6 million vertices have been tested, forcing the authors to artificially restrict the main memory size, M, to rather unrealistic 4 to 16 MBytes in order not to leave the semiexternal setting or produce huge running times for larger graphs: for random graphs of 2 20 vertices, the best previous approach needed over six hours. In contrast, for a similar ratio of input size vs. M, but on a 128 times larger and even sparser random graph, our approach was less than seven times slower, a relative gain of nearly 20. On a realworld 24 million node street graph, our implementation was over 40 times faster. Even larger gains of over 500 can be estimated for ran
Priority Queues and Dijkstra’s Algorithm
, 2007
"... We study the impact of using different priority queues in the performance of Dijkstra’s SSSP algorithm. We consider only general priority queues that can handle any type of keys (integer, floating point, etc.); the only exception is that we use as a benchmark the DIMACS Challenge SSSP code [1] which ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
We study the impact of using different priority queues in the performance of Dijkstra’s SSSP algorithm. We consider only general priority queues that can handle any type of keys (integer, floating point, etc.); the only exception is that we use as a benchmark the DIMACS Challenge SSSP code [1] which can handle only integer values for distances. Our experiments were focussed on the following: 1. We study the performance of two variants of Dijkstra’s algorithm: the wellknown version that uses a priority queue that supports the DecreaseKey operation, and another that uses a basic priority queue that supports only Insert and DeleteMin. For the latter type of priority queue we include several for which highperformance code is available such as bottomup binary heap, aligned 4ary heap, and sequence heap [33]. 2. We study the performance of Dijkstra’s algorithm designed for flat memory relative to versions that try to be cacheefficient. For this, in main part, we study the difference in performance of Dijkstra’s algorithm relative to the cacheefficiency of the priority queue used, both incore and outofcore. We also study the performance of an implementation
A faster cacheoblivious shortestpath algorithm for undirected graphs with bounded edge lengths
 In SODA ’07
"... We present a cacheoblivious algorithm for computing singlesource shortest paths in undirected graphs with nonnegative edge lengths. The algorithm incurs O ( √ (nm log W)/B +(m/B)logn+MST(n, m) ) memory transfers on a graph with n vertices, m edges, and real edge lengths between 1 and W; B denotes ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
(Show Context)
We present a cacheoblivious algorithm for computing singlesource shortest paths in undirected graphs with nonnegative edge lengths. The algorithm incurs O ( √ (nm log W)/B +(m/B)logn+MST(n, m) ) memory transfers on a graph with n vertices, m edges, and real edge lengths between 1 and W; B denotes the cache block size, and MST(n, m) denotes the number of memory transfers required to compute a minimum spanning tree of a graph with n vertices and m edges. Our algorithm is the first cacheoblivious shortestpath algorithm incurring less than one memory transfer per vertex if the graph is sparse (m =O(n)) and W =2o(B). 1
I/OOptimal Algorithms for Outerplanar Graphs
, 2001
"... We present linearI/O algorithms for fundamental graph problems on embedded outerplanar graphs. We show that breadthfirst search, depthfirst search, singlesource shortest paths, triangulation, and computing an ɛseparator of size O(1/ɛ) takeO(scan(N)) I/Os on embedded outerplanar graphs. We also s ..."
Abstract

Cited by 1 (1 self)
 Add to MetaCart
(Show Context)
We present linearI/O algorithms for fundamental graph problems on embedded outerplanar graphs. We show that breadthfirst search, depthfirst search, singlesource shortest paths, triangulation, and computing an ɛseparator of size O(1/ɛ) takeO(scan(N)) I/Os on embedded outerplanar graphs. We also show that it takes O(sort(N)) I/Os to test whether a given graph is outerplanar and to compute an outerplanar embedding of an outerplanar graph, thereby providing O(sort(N))I/O algorithms for the above problems if no embedding of the graph is given. As all these problems have lineartime algorithms in internal memory, a simple simulation technique can be used to improve the I/Ocomplexity of our algorithms from O(sort(N)) to O(perm(N)). We prove matching lower bounds for embedding, breadthfirst search, depthfirst search, and singlesource shortest paths if no embedding is given. Our algorithms for the above problems use a simple linearI/O timeforward processing algorithm for rooted trees whose vertices are stored in preorder.