Showing papers by "Gerth Stølting Brodal published in 1997"

A parallel priority data structure with applications

Abstract: Presents a parallel priority data structure that improves the running time of certain algorithms for problems that lack a fast and work-efficient parallel solution. As a main application, we give a parallel implementation of Dijkstra's (1959) algorithm which runs in O(n) time while performing O(m log n) work on a CREW PRAM. This is a logarithmic factor improvement for the running time compared with previous approaches. The main feature of our data structure is that the operations needed in each iteration of Dijkstra's algorithm can be supported in O(1) time.

Worst Case Efficient Data Structures

Abstract: We study the design of efficient data structures. In particular we focus on the design of data structures where each operation has a worst case efficient implementations. The concrete problems we consider are partial persistence, implementation of priority queues, and implementation of dictionaries. The first problem we consider is how to make bounded in-degree and out-degree data structures partially persistent, i.e., how to remember old versions of a data structure for later access. A node copying technique of Driscoll et al. supports update steps in amortized constant time and access steps in worst case constant time. The worst case time for an update step can be linear in the size of the structure. We show how to extend the technique of Driscoll et al. such that update steps can be performed in worst case constant time on the pointer machine model. We present two new comparison based priority queue implementations, with the following properties. The first implementation supports the operations FindMin, Insert and Meld in worst case constant time and Delete and DeleteMin in worst case time O(log n). The priority queues can be implemented on the pointer machine and require linear space. The second implementation achieves the same worst case performance, but furthermore supports DecreaseKey in worst case constant time. The space requirement is again linear, but the implementation requires auxiliary arrays of size O(log n). Our bounds match the best known amortized bounds (achieved by respectively binomial queues and Fibonacci heaps). The data structures presented are the first achieving these worst case bounds, in particular supporting Meld in worst case constant time. We show that these time bounds are optimal for all implementations supporting Meld in worst case time o(n). We also present a tradeoff between the update time and the query time of comparison based priority queue implementations. Finally we show that any randomized implementation with expected amortized cost t comparisons per Insert and Delete operation has expected cost at least n/2O(t) comparisons for FindMin. Next we consider how to implement priority queues on parallel (comparison based) models. We present time and work optimal priority queues for the CREW PRAM, supporting FindMin, Insert, Meld, DeleteMin, Delete and DecreaseKey in constant time with O(log n) processors. Our implementation is the first supporting all of the listed operations in constant time. To be able to speed up Dijkstra’s algorithm for the single-source shortest path problem we present a different parallel priority data structure. With this specialized data structure we give a parallel implementation of Dijkstra’s algorithm which runs in O(n) time and performs O(m log n) work on a CREW PRAM. This represents a logarithmic factor improvement for the running time compared with previous approaches. We also consider priority queues on a RAM model which is stronger than the comparison model. The specific problem is the maintenance of a set of n integers in the range 0..2 − 1 under the operations Insert, Delete, FindMin, FindMax and Pred (predecessor query) on a unit cost RAM with word size w bits. The RAM operations used are addition, left and right bit shifts,

Predecessor Queries in Dynamic Integer Sets

Abstract: We consider the problem of maintaining a set of n integers in the range 02w−1 under the operations of insertion, deletion, predecessor queries, minimum queries and maximum queries on a unit cost RAM with word size w bits Let f (n) be an arbitrary nondecreasing smooth function satisfying \(n \leqslant f(n) \leqslant \sqrt {log n} \) A data structure is presented supporting insertions and deletions in worst case O(f(n)) time, predecessor queries in worst case O((logn)/f(n)) time and minimum and maximum queries in worst case constant time The required space is O(n2∈w) for an arbitrary constant ∈ > 0 The RAM operations used are addition, arbitrary left and right bit shifts and bit-wise boolean operations The data structure is the first supporting predecessor queries in worst case O(log n/log log n) time while having worst case O(log log n) update time

Predecessor Queries in Dynamic Integer Sets

Abstract: We consider the problem of maintaining a set of n integers in the range 0.2w−1 under the operations of insertion, deletion, predecessor queries, minimum queries and maximum queries on a unit cost RAM with word size w bits. Let f (n) be an arbitrary nondecreasing smooth function satisfying \(n \leqslant f(n) \leqslant \sqrt {log n} \). A data structure is presented supporting insertions and deletions in worst case O(f(n)) time, predecessor queries in worst case O((logn)/f(n)) time and minimum and maximum queries in worst case constant time. The required space is O(n2∈w) for an arbitrary constant ∈ > 0. The RAM operations used are addition, arbitrary left and right bit shifts and bit-wise boolean operations. The data structure is the first supporting predecessor queries in worst case O(log n/log log n) time while having worst case O(log log n) update time.

A parallel priority data structure with applications

Abstract: Presents a parallel priority data structure that improves the running time of certain algorithms for problems that lack a fast and work-efficient parallel solution. As a main application, we give a parallel implementation of Dijkstra's (1959) algorithm which runs in O(n) time while performing O(m log n) work on a CREW PRAM. This is a logarithmic factor improvement for the running time compared with previous approaches. The main feature of our data structure is that the operations needed in each iteration of Dijkstra's algorithm can be supported in O(1) time.