Results 1  10
of
24
Finding the k Shortest Paths
, 1997
"... We give algorithms for finding the k shortest paths (not required to be simple) connecting a pair of vertices in a digraph. Our algorithms output an implicit representation of these paths in a digraph with n vertices and m edges, in time O(m + n log n + k). We can also find the k shortest pat ..."
Abstract

Cited by 401 (2 self)
 Add to MetaCart
We give algorithms for finding the k shortest paths (not required to be simple) connecting a pair of vertices in a digraph. Our algorithms output an implicit representation of these paths in a digraph with n vertices and m edges, in time O(m + n log n + k). We can also find the k shortest paths from a given source s to each vertex in the graph, in total time O(m + n log n +kn). We describe applications to dynamic programming problems including the knapsack problem, sequence alignment, maximum inscribed polygons, and genealogical relationship discovery.
Faster ShortestPath Algorithms for Planar Graphs
 STOC 94
, 1994
"... We give a lineartime algorithm for singlesource shortest paths in planar graphs with nonnegative edgelengths. Our algorithm also yields a lineartime algorithm for maximum flow in a planar graph with the source and sink on the same face. The previous best algorithms for these problems required\O ..."
Abstract

Cited by 204 (17 self)
 Add to MetaCart
We give a lineartime algorithm for singlesource shortest paths in planar graphs with nonnegative edgelengths. Our algorithm also yields a lineartime algorithm for maximum flow in a planar graph with the source and sink on the same face. The previous best algorithms for these problems required\Omega\Gamma n p log n) time where n is the number of nodes in the input graph. For the case where negative edgelengths are allowed, we give an algorithm requiring O(n 4=3 log nL) time, where L is the absolute value of the most negative length. Previous algorithms for shortest paths with negative edgelengths required \Omega\Gamma n 3=2 ) time. Our shortestpath algorithm yields an O(n 4=3 log n)time algorithm for finding a perfect matching in a planar bipartite graph. A similar improvement is obtained for maximum flow in a directed planar graph.
Ambivalent data structures for dynamic 2edgeconnectivity and k smallest spanning trees
 In 32nd Annual Symposium on Foundations of Computer Science FOCS
, 1991
"... ..."
(Show Context)
Algorithms for Proximity Problems in Higher Dimensions
 Comput. Geom. Theory Appl
, 1996
"... We present algorithms for five interdistance enumeration problems that take as input a set S of n points in IR d (for a fixed but arbitrary dimension d) and as output enumerate pairs of points in S satisfying various conditions. We present: an O(n log n + k) time and O(n) space algorithm that ..."
Abstract

Cited by 25 (2 self)
 Add to MetaCart
We present algorithms for five interdistance enumeration problems that take as input a set S of n points in IR d (for a fixed but arbitrary dimension d) and as output enumerate pairs of points in S satisfying various conditions. We present: an O(n log n + k) time and O(n) space algorithm that takes as additional input a distance # and outputs all k pairs of points in S separated by a distance of # or less; an O(n log n + k log k) time and O(n+k) space algorithm that enumerates in nondecreasing order the k closest pairs of points in S; an O(n log n + k) time algorithm for the same problem without any order restrictions; an O(nk log n) time and O(n) space algorithm that enumerates in nondecreasing order the nk pairs representing the k nearest neighbors of each point in S; and an O(n log n + kn) time algorithm for the same problem without any order restrictions. The algorithms combine a modification of the planar approach of Dickerson, Drysdale, and Sack [11] with the ...
A Linear Time Algorithm for the k Maximal Sums Problem
"... Abstract. Finding the subvector with the largest sum in a sequence of n numbers is known as the maximum sum problem. Finding the k subvectors with the largest sums is a natural extension of this, and is known as the k maximal sums problem. In this paper we design an optimal O(n+k) time algorithm f ..."
Abstract

Cited by 12 (2 self)
 Add to MetaCart
(Show Context)
Abstract. Finding the subvector with the largest sum in a sequence of n numbers is known as the maximum sum problem. Finding the k subvectors with the largest sums is a natural extension of this, and is known as the k maximal sums problem. In this paper we design an optimal O(n+k) time algorithm for the k maximal sums problem. We use this algorithm to obtain algorithms solving the twodimensional k maximal sums problem in O(m 2 ·n+k) time, where the input is an m ×n matrix with m ≤ n. We generalize this algorithm to solve the ddimensional problem in O(n 2d−1 +k) time. The space usage of all the algorithms can be reduced to O(n d−1 + k). This leads to the first algorithm for the k maximal sums problem in one dimension using O(n + k) time and O(k) space. 1
Ranksensitive data structures
 In Proc. 12th International Symposium on String Processing and Information Retrieval (SPIRE), LNCS v. 3772
, 2005
"... Abstract. Outputsensitive data structures result from preprocessing n items and are capable of reporting the items satisfying an online query in O(t(n) + ℓ) time, where t(n) is the cost of traversing the structure and ℓ ≤ n is the number of reported items satisfying the query. In this paper we foc ..."
Abstract

Cited by 8 (0 self)
 Add to MetaCart
(Show Context)
Abstract. Outputsensitive data structures result from preprocessing n items and are capable of reporting the items satisfying an online query in O(t(n) + ℓ) time, where t(n) is the cost of traversing the structure and ℓ ≤ n is the number of reported items satisfying the query. In this paper we focus on ranksensitive data structures, which are additionally given a ranking of the n items, so that just the top k bestranking items should be reported at query time, sorted in rank order, at a cost of O(t(n) + k) time. Note that k is part of the query as a parameter under the control of the user (as opposed to ℓ which is querydependent). We explore the problem of adding ranksensitivity to data structures such as suffix trees or range trees, where the ℓ items satisfying the query form O(polylog(n)) intervals of consecutive entries from which we choose the top k bestranking ones. Letting s(n) be the number of items (including their copies) stored in the original data structures, we increase the space by an additional term of O(s(n) lg ǫ n) memory words of space, each of O(lg n) bits, for any positive constant ǫ < 1. We allow for changing the ranking on the fly during the lifetime of the data structures, with ranking values in 0... O(n). In this case, query time becomes O(t(n)+k) plus O(lg n/lg lg n) per interval; each change in the ranking and each insertion/deletion of an item takes O(lg n) time; the additional term in space occupancy increases to O(s(n) lg n/lg lg n). 1
K : A heuristic search algorithm for finding the k shortest paths
 Artificial Intelligence
"... We present a directed search algorithm, called K ∗ , for finding the k shortest paths between a designated pair of vertices in a given directed weighted graph. K ∗ has two advantages compared to current kshortestpaths algorithms. First, K ∗ operates onthefly, which means that it does not require ..."
Abstract

Cited by 7 (1 self)
 Add to MetaCart
(Show Context)
We present a directed search algorithm, called K ∗ , for finding the k shortest paths between a designated pair of vertices in a given directed weighted graph. K ∗ has two advantages compared to current kshortestpaths algorithms. First, K ∗ operates onthefly, which means that it does not require the graph to be explicitly available and stored in main memory. Portions of the graph will be generated as needed. Second, K ∗ can be guided using heuristic functions. We prove the correctness of K ∗ and determine its asymptotic worstcase complexity when using a consistent heuristic to be the same as the state of the art, O(m + n log n + k), with respect to both runtime and space, where n is the number of vertices and m is the number of edges of the graph. We present an experimental evaluation of K ∗ by applying it to route planning problems as well as counterexample generation for stochastic model checking. The experimental results illustrate that due to the use of heuristic, onthefly search K ∗ can use less time and memory compared to the most efficient kshortestpaths algorithms known so far. Key words: kshortestpaths problem; K ∗ ; heuristic search; onthefly search 1.
Finding a Realistic Detour by AI Search Techniques
, 1997
"... In the navigation system, it is very important not only to find the shortest path but also a detour, in case of a traffic jam for example. This paper surveys algorithms for the shortest path problem and the k shortest path problem at first, extends the latter algorithm for the 2terminal k shortest ..."
Abstract

Cited by 6 (2 self)
 Add to MetaCart
In the navigation system, it is very important not only to find the shortest path but also a detour, in case of a traffic jam for example. This paper surveys algorithms for the shortest path problem and the k shortest path problem at first, extends the latter algorithm for the 2terminal k shortest paths problem, using AI search techniques such as the bidirectional A 3 algorithm, then defines `detour' precisely, and proposes algorithms for finding a realistic detour based on these algorithms. The efficiency and property of the algorithms are examined through experiments on an actual road network. 1. INTRODUCTION The shortest path problem is very important in various fields. For example, route navigation systems must show the shortest route to the destination as fast as possible. Thus, the shortest path problem is studied very well for a long time. For example, the Dijkstra method is the most famous and traditional algorithm for this problem. To make this algorithm more efficient, m...
Finding the k Shortest Paths in Parallel
, 2000
"... . A concurrentread exclusivewrite PRAM algorithm is developed to find the k shortest paths between pairs of vertices in an edgeweighted directed graph. Repetitions of vertices along the paths are allowed. The algorithm computes an implicit representation of the k shortest paths to a given destina ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
. A concurrentread exclusivewrite PRAM algorithm is developed to find the k shortest paths between pairs of vertices in an edgeweighted directed graph. Repetitions of vertices along the paths are allowed. The algorithm computes an implicit representation of the k shortest paths to a given destination vertex from every vertex of a graph with n vertices and m edges, using O(m +nk log 2 k) work and O(log 3 k log # k + log n(log log k +log # n)) time, assuming that a shortest path tree rooted at the destination is precomputed. The paths themselves can be extracted from the implicit representation in O(log k +log n) time, and O(n log n+L) work, where L is the total length of the output. Key Words. Parallel graph algorithms, Data structures, Shortest paths. 1. Introduction. The problem of finding shortest paths in an edgeweighted graph is an important and wellstudied problem in computer science. The more general problem of computing the k shortest paths between vertices of...
Fast Deterministic Parallel BranchandBound
, 1999
"... The branchandbound problem involves determining the minimum cost leaf in a costlabelled tree, subject to the constraint that only the root is known initially and that children are revealed only by visiting their parent. We present the first efficient deterministic algorithm to solve the branchand ..."
Abstract

Cited by 4 (2 self)
 Add to MetaCart
The branchandbound problem involves determining the minimum cost leaf in a costlabelled tree, subject to the constraint that only the root is known initially and that children are revealed only by visiting their parent. We present the first efficient deterministic algorithm to solve the branchand bound problem for a tree T of constant degree on a pprocessor parallel machine. Let c be the cost of the minimumcost leaf in T , and let n and h be the number of nodes and the height, respectively, of the subtree T ` T of nodes of cost less than or equal to c . Our algorithm runs in O i n=p + h log 2 (np) j time on an EREWPRAM. Moreover, the running time faithfully reflects both communication and computation costs, unlike most of the previous results where the cost of local computation is ignored. For large ranges of the parameters, our algorithm matches the optimal performance of existing randomized strategies. The algorithm can be ported to any architecture for which an...