Results 1  10
of
30
A New Approach to AllPairs Shortest Paths on RealWeighted Graphs
 Theoretical Computer Science
, 2003
"... We present a new allpairs shortest path algorithm that works with realweighted graphs in the traditional comparisonaddition model. It runs in O(mn+n time, improving on the longstanding bound of O(mn + n log n) derived from an implementation of Dijkstra's algorithm with Fibonacci heaps ..."
Abstract

Cited by 29 (2 self)
 Add to MetaCart
We present a new allpairs shortest path algorithm that works with realweighted graphs in the traditional comparisonaddition model. It runs in O(mn+n time, improving on the longstanding bound of O(mn + n log n) derived from an implementation of Dijkstra's algorithm with Fibonacci heaps. Here m and n are the number of edges and vertices, respectively.
Integer Priority Queues with Decrease Key in . . .
 STOC'03
, 2003
"... We consider Fibonacci heap style integer priority queues supporting insert and decrease key operations in constant time. We present a deterministic linear space solution that with n integer keys support delete in O(log log n) time. If the integers are in the range [0,N), we can also support delete i ..."
Abstract

Cited by 27 (2 self)
 Add to MetaCart
We consider Fibonacci heap style integer priority queues supporting insert and decrease key operations in constant time. We present a deterministic linear space solution that with n integer keys support delete in O(log log n) time. If the integers are in the range [0,N), we can also support delete in O(log log N) time. Even for the special case of monotone priority queues, where the minimum has to be nondecreasing, the best previous bounds on delete were O((log n) 1/(3−ε) ) and O((log N) 1/(4−ε)). These previous bounds used both randomization and amortization. Our new bounds a deterministic, worstcase, with no restriction to monotonicity, and exponentially faster. As a classical application, for a directed graph with n nodes and m edges with nonnegative integer weights, we get single source shortest paths in O(m + n log log n) time, or O(m + n log log C) ifC is the maximal edge weight. The later solves an open problem of Ahuja, Mehlhorn, Orlin, and
Selfimproving algorithms
 in SODA ’06: Proceedings of the seventeenth annual ACMSIAM symposium on Discrete algorithm
"... We investigate ways in which an algorithm can improve its expected performance by finetuning itself automatically with respect to an arbitrary, unknown input distribution. We give such selfimproving algorithms for sorting and computing Delaunay triangulations. The highlights of this work: (i) an al ..."
Abstract

Cited by 25 (4 self)
 Add to MetaCart
(Show Context)
We investigate ways in which an algorithm can improve its expected performance by finetuning itself automatically with respect to an arbitrary, unknown input distribution. We give such selfimproving algorithms for sorting and computing Delaunay triangulations. The highlights of this work: (i) an algorithm to sort a list of numbers with optimal expected limiting complexity; and (ii) an algorithm to compute the Delaunay triangulation of a set of points with optimal expected limiting complexity. In both cases, the algorithm begins with a training phase during which it adjusts itself to the input distribution, followed by a stationary regime in which the algorithm settles to its optimized incarnation. 1
A shortest path algorithm for realweighted undirected graphs
 in 13th ACMSIAM Symp. on Discrete Algs
, 1985
"... Abstract. We present a new scheme for computing shortest paths on realweighted undirected graphs in the fundamental comparisonaddition model. In an efficient preprocessing phase our algorithm creates a linearsize structure that facilitates singlesource shortest path computations in O(m log α) ti ..."
Abstract

Cited by 12 (3 self)
 Add to MetaCart
(Show Context)
Abstract. We present a new scheme for computing shortest paths on realweighted undirected graphs in the fundamental comparisonaddition model. In an efficient preprocessing phase our algorithm creates a linearsize structure that facilitates singlesource shortest path computations in O(m log α) time, where α = α(m, n) is the very slowly growing inverseAckermann function, m the number of edges, and n the number of vertices. As special cases our algorithm implies new bounds on both the allpairs and singlesource shortest paths problems. We solve the allpairs problem in O(mnlog α(m, n)) time and, if the ratio between the maximum and minimum edge lengths is bounded by n (log n)O(1) , we can solve the singlesource problem in O(m + nlog log n) time. Both these results are theoretical improvements over Dijkstra’s algorithm, which was the previous best for real weighted undirected graphs. Our algorithm takes the hierarchybased approach invented by Thorup. Key words. singlesource shortest paths, allpairs shortest paths, undirected graphs, Dijkstra’s
Radix sorting with no extra space
 In Proceedings of the 15th European Symposium on Algorithms
, 2007
"... It is well known that n integers in the range [1, n c] can be sorted in O(n) time in the RAM model using radix sorting. More generally, integers in any range [1, U] can be sorted in O(n √ log log n) time [5]. However, these algorithms use O(n) words of extra memory. Is this necessary? We present a s ..."
Abstract

Cited by 9 (0 self)
 Add to MetaCart
(Show Context)
It is well known that n integers in the range [1, n c] can be sorted in O(n) time in the RAM model using radix sorting. More generally, integers in any range [1, U] can be sorted in O(n √ log log n) time [5]. However, these algorithms use O(n) words of extra memory. Is this necessary? We present a simple, stable, integer sorting algorithm for words of size O(log n), which works in O(n) time and uses only O(1) words of extra memory on a RAM model. This is the integer sorting case most useful in practice. We extend this result with same bounds to the case when the keys are readonly, which is of theoretical interest. Another interesting question is the case of arbitrary c. Here we present a blackbox transformation from any RAM sorting algorithm to a sorting algorithm which uses only O(1) extra space and has the same running time. This settles the complexity of inplace sorting in terms of the complexity of sorting. 1
Delaunay Triangulations in O(sort(n)) Time and More
"... We present several results about Delaunay triangulations (DTs) and convex hulls in transdichotomous and hereditary settings: (i) the DT of a planar point set can be computed in expected time O(sort(n)) on a word RAM, where sort(n) is the time to sort n numbers. We assume that the word RAM supports ..."
Abstract

Cited by 8 (4 self)
 Add to MetaCart
(Show Context)
We present several results about Delaunay triangulations (DTs) and convex hulls in transdichotomous and hereditary settings: (i) the DT of a planar point set can be computed in expected time O(sort(n)) on a word RAM, where sort(n) is the time to sort n numbers. We assume that the word RAM supports the shuffleoperation in constant time; (ii) if we know the ordering of a planar point set in x and in ydirection, its DT can be found by a randomized algebraic computation tree of expected linear depth; (iii) given a universe U of points in the plane, we construct a data structure D for Delaunay queries: for any P ⊆ U, D can find the DT of P in time O(P  log log U); (iv) given a universe U of points in 3space in general convex position, there is a data structure D for convex hull queries: for any P ⊆ U, D can find the convex hull of P in time O(P (log log U) 2); (v) given a convex polytope in 3space with n vertices which are colored with χ> 2 colors, we can split it into the convex hulls of the individual color classes in time O(n(log log n) 2). The results (i)–(iii) generalize to higher dimensions. We need a wide range of techniques. Most prominently, we describe a reduction from DTs to nearestneighbor graphs that relies on a new variant of randomized incremental constructions using dependent sampling.
Faster algorithms for incremental topological ordering
 In ICALP
, 2008
"... Abstract. We present two online algorithms for maintaining a topological order of a directed acyclic graph as arcs are added, and detecting a cycle when one is created. Our first algorithm takes O(m 1/2) amortized time per arc and our second algorithm takes O(n 2.5 /m) amortized time per arc, where ..."
Abstract

Cited by 7 (1 self)
 Add to MetaCart
(Show Context)
Abstract. We present two online algorithms for maintaining a topological order of a directed acyclic graph as arcs are added, and detecting a cycle when one is created. Our first algorithm takes O(m 1/2) amortized time per arc and our second algorithm takes O(n 2.5 /m) amortized time per arc, where n is the number of vertices and m is the total number of arcs. For sparse graphs, our O(m 1/2) bound improves the best previous bound by a factor of log n and is tight to within a constant factor for a natural class of algorithms that includes all the existing ones. Our main insight is that the twoway search method of previous algorithms does not require an ordered search, but can be more general, allowing us to avoid the use of heaps (priority queues). Instead, the deterministic version of our algorithm uses (approximate) medianfinding; the randomized version of our algorithm uses uniform random sampling. For dense graphs, our O(n 2.5 /m) bound improves the best previously published bound by a factor of n 1/4 and a recent bound obtained independently of our work by a factor of log n. Our main insight is that graph search is wasteful when the graph is dense and can be avoided by searching the topological order space instead. Our algorithms extend to the maintenance of strong components, in the same asymptotic time bounds. 1
Persistent Predecessor Search and Orthogonal Point Location on the Word RAM
"... We answer a basic data structuring question (for example, raised by Dietz and Raman back in SODA 1991): can van Emde Boas trees be made persistent, without changing their asymptotic query/update time? We present a (partially) persistent data structure that supports predecessor search in a set of int ..."
Abstract

Cited by 6 (3 self)
 Add to MetaCart
(Show Context)
We answer a basic data structuring question (for example, raised by Dietz and Raman back in SODA 1991): can van Emde Boas trees be made persistent, without changing their asymptotic query/update time? We present a (partially) persistent data structure that supports predecessor search in a set of integers in {1,..., U} under an arbitrary sequence of n insertions and deletions, with O(log log U) expected query time and expected amortized update time, and O(n) space. The query bound is optimal in U for linearspace structures and improves previous nearO((log log U) 2) methods. The same method solves a fundamental problem from computational geometry: point location in orthogonal planar subdivisions (where edges are vertical or horizontal). We obtain the first static data structure achieving O(log log U) worstcase query time and linear space. This result is again optimal in U for linearspace structures and improves the previous O((log log U) 2) method by de Berg, Snoeyink, and van Kreveld (1992). The same result also holds for higherdimensional subdivisions that are orthogonal binary space partitions, and for certain nonorthogonal planar subdivisions such as triangulations without small angles. Many geometric applications follow, including improved query times for orthogonal range reporting for dimensions ≥ 3 on the RAM. Our key technique is an interesting new vanEmdeBoas–style recursion that alternates between two strategies, both quite simple.
On adaptive integer sorting
 In 12th Annual European Symposium on Algorithms, ESA 2004
, 2004
"... Abstract. This paper considers integer sorting on a RAM. We show that adaptive sorting of a sequence with qn inversions is asymptotically equivalent to multisorting groups of at most q keys, and a total of n keys. Using the recent O(n √ log log n) expected time sorting of Han and Thorup on each set, ..."
Abstract

Cited by 5 (0 self)
 Add to MetaCart
(Show Context)
Abstract. This paper considers integer sorting on a RAM. We show that adaptive sorting of a sequence with qn inversions is asymptotically equivalent to multisorting groups of at most q keys, and a total of n keys. Using the recent O(n √ log log n) expected time sorting of Han and Thorup on each set, we immediately get an adaptive expected sorting time of O(n √ log log q). Interestingly, for any positive constant ε, we show that multisorting and adaptive inversion sorting can be performed in (log n)1−ε linear time if q ≤ 2. We also show how to asymptotically improve the running time of any traditional sorting algorithm on a class of inputs much broader than those with few inversions. 1
Generic Discrimination  Sorting and Partitioning Unshared Data in Linear Time
, 2008
"... We introduce the notion of discrimination as a generalization of both sorting and partitioning and show that worstcase lineartime discrimination functions (discriminators) can be defined generically, by (co)induction on an expressive language of order denotations. The generic definition yields di ..."
Abstract

Cited by 5 (4 self)
 Add to MetaCart
We introduce the notion of discrimination as a generalization of both sorting and partitioning and show that worstcase lineartime discrimination functions (discriminators) can be defined generically, by (co)induction on an expressive language of order denotations. The generic definition yields discriminators that generalize both distributive sorting and multiset discrimination. The generic discriminator can be coded compactly using list comprehensions, with order denotations specified using Generalized Algebraic Data Types (GADTs). A GADTfree combinator formulation of discriminators is also given. We give some examples of the uses of discriminators, including a new mostsignificantdigit lexicographic sorting algorithm. Discriminators generalize binary comparison functions: They operate on n arguments at a time, but do not expose more information than the underlying equivalence, respectively ordering relation on the arguments. We argue that primitive types with equality (such as references in ML) and ordered types (such as the machine integer type), should expose their equality, respectively standard ordering relation, as discriminators: Having only a binary equality test on a type requires Θ(n 2) time to find all the occurrences of an element in a list of length n, for each element in the list, even if the equality test takes only constant time. A discriminator accomplishes this in linear time. Likewise, having only a (constanttime) comparison function requires Θ(n log n) time to sort a list of n elements. A discriminator can do this in linear time.