Results 1  10
of
24
Twotier relaxed heaps
 Proceedings of the 17th International Symposium on Algorithms and Computation, Lecture Notes in Computer Science 4288, SpringerVerlag
, 2006
"... Abstract. We introduce an adaptation of runrelaxed heaps which provides efficient heap operations with respect to the number of element comparisons performed. Our data structure guarantees the worstcase cost of O(1) for findmin, insert, and decrease; and the worstcase cost of O(lg n) with at mos ..."
Abstract

Cited by 11 (8 self)
 Add to MetaCart
(Show Context)
Abstract. We introduce an adaptation of runrelaxed heaps which provides efficient heap operations with respect to the number of element comparisons performed. Our data structure guarantees the worstcase cost of O(1) for findmin, insert, and decrease; and the worstcase cost of O(lg n) with at most lg n + 3 lg lg n + O(1) element comparisons for delete, improving the bound of 3lg n + O(1) on the number of element comparisons known for runrelaxed heaps. Here, n denotes the number of elements stored prior to the operation in question, and lg n equals max {1, log 2 n}. 1
Proximate point searching
 In Proceedings of the 14th Canadian Conference on Computational Geometry (CCCG
, 2002
"... In the 2D point searching problem, the goal is to preprocess n points P = {p1,..., pn} in the plane so that, for an online sequence of query points q1,..., qm, it can quickly determined which (if any) of the elements of P are equal to each query point qi. This problem can be solved in O(log n) time ..."
Abstract

Cited by 10 (4 self)
 Add to MetaCart
In the 2D point searching problem, the goal is to preprocess n points P = {p1,..., pn} in the plane so that, for an online sequence of query points q1,..., qm, it can quickly determined which (if any) of the elements of P are equal to each query point qi. This problem can be solved in O(log n) time by mapping the problem to one dimension. We present a data structure that is optimized for answering queries quickly when they are geometrically close to the previous successful query. Specifically, our data structure executes queries in time O(log d(qi−1, qi)), where d is some distance function between two points, and uses O(n log n) space. Our structure works with a variety of distance functions. In contrast, it is proved that, for some of the most intuitive distance functions d, it is impossible to obtain an O(log d(qi−1, qi)) runtime, or any bound that is o(log n).
Pairing heaps with O(log log n) decrease cost
 In 20th ACMSIAM Symposium on Discrete Algorithms
, 2009
"... We give a variation of the pairing heaps for which the time bounds for all the operations match the lower bound proved by Fredman for a family of similar selfadjusting heaps. Namely, our heap structure requires O(1) for insert and findmin, O(log n) for deletemin, and O(log log n) for decreasekey a ..."
Abstract

Cited by 10 (3 self)
 Add to MetaCart
(Show Context)
We give a variation of the pairing heaps for which the time bounds for all the operations match the lower bound proved by Fredman for a family of similar selfadjusting heaps. Namely, our heap structure requires O(1) for insert and findmin, O(log n) for deletemin, and O(log log n) for decreasekey and meld (all the bounds are in the amortized sense except for findmin). 1
A framework for speeding up priorityqueue operations
, 2004
"... Abstract. We introduce a framework for reducing the number of element comparisons performed in priorityqueue operations. In particular, we give a priority queue which guarantees the worstcase cost of O(1) per minimum finding and insertion, and the worstcase cost of O(log n) with at most log n + O ..."
Abstract

Cited by 8 (7 self)
 Add to MetaCart
(Show Context)
Abstract. We introduce a framework for reducing the number of element comparisons performed in priorityqueue operations. In particular, we give a priority queue which guarantees the worstcase cost of O(1) per minimum finding and insertion, and the worstcase cost of O(log n) with at most log n + O(1) element comparisons per minimum deletion and deletion, improving the bound of 2log n + O(1) on the number of element comparisons known for binomial queues. Here, n denotes the number of elements stored in the data structure prior to the operation in question, and log n equals max {1,log 2 n}. We also give a priority queue that provides, in addition to the abovementioned methods, the prioritydecrease (or decreasekey) method. This priority queue achieves the worstcase cost of O(1) per minimum finding, insertion, and priority decrease; and the worstcase cost of O(log n) with at most log n + O(log log n) element comparisons per minimum deletion and deletion. CR Classification. E.1 [Data Structures]: Lists, stacks, and queues; E.2 [Data
GMSim: A generalized semiMarkov simulation environment
, 1998
"... A discreteevent simulation environment, called GMSim, based on the generalized semiMarkov process (GSMP) framework is described. The tool is completely generic and extendible by Tcl script programming. Application specific components are developed in an objectedoriented setting by C++ programming ..."
Abstract

Cited by 5 (5 self)
 Add to MetaCart
A discreteevent simulation environment, called GMSim, based on the generalized semiMarkov process (GSMP) framework is described. The tool is completely generic and extendible by Tcl script programming. Application specific components are developed in an objectedoriented setting by C++ programming in combination with M4 macro processing. Components are conveniently integrated by runtime linking. The strong links to the underlying mathematical GSMP description is favorable in two respects. First, qualitative results from a body of theory is readily available. Next, the structured view leads to an efficient implementation.
GMSim: A Tool For Compositional GSMP Modeling
 IN PROC. OF THE 1998 WINTER SIMULATION CONFERENCE (WASHINGTON DC, DEC
, 1998
"... The development of a discreteevent simulation tool, called GMSim, based on the generalized semiMarkov process (GSMP) formalism is described. The GSMP representation comprises both analysis and simulation in a unied framework. This paper focuses on the simulation aspect and how to deal with a combi ..."
Abstract

Cited by 4 (1 self)
 Add to MetaCart
The development of a discreteevent simulation tool, called GMSim, based on the generalized semiMarkov process (GSMP) formalism is described. The GSMP representation comprises both analysis and simulation in a unied framework. This paper focuses on the simulation aspect and how to deal with a combinatorially exploding state space. A compositional GSMP modeling methodology is proposed, which in turn combined with an objectoriented programming approach. A key feature of the resulting tool is the close resemblance with the underlying mathematical structure. This facilitates coherent modeling and also an efficient implementation. The tool is completely generic and extendible by Tcl script programming. Application specific components are developed by C++ programming in combination with M4 macro processing.
Pairing Heaps with Costless Meld
, 2009
"... Improving the structure and analysis in [1], we give a variation of the pairing heaps that has amortized zero cost per meld (compared to an O(log log n) in [1]) and the same amortized bounds for all other operations. More precisely, the new pairing heap requires: no cost per meld, O(1) per findmin ..."
Abstract

Cited by 4 (0 self)
 Add to MetaCart
(Show Context)
Improving the structure and analysis in [1], we give a variation of the pairing heaps that has amortized zero cost per meld (compared to an O(log log n) in [1]) and the same amortized bounds for all other operations. More precisely, the new pairing heap requires: no cost per meld, O(1) per findmin and insert, O(log n) per deletemin, and O(log log n) per decreasekey. These bounds are the best known for any selfadjusting heap, and match the lower bound proven by Fredman for a family of such heaps. Moreover, our structure is even simpler than that in [1].
Combining Lagrangian decomposition with an evolutionary algorithm for the knapsack constrained maximum spanning tree problem
 EVOLUTIONARY COMPUTATION IN COMBINATORIAL OPTIMISATION  EVOCOP 2007. VOLUME 4446 OF LNCS
, 2007
"... We present a Lagrangian decomposition approach for the Knapsack Constrained Maximum Spanning Tree problem yielding upper bounds as well as heuristic solutions. This method is further combined with an evolutionary algorithm to a sequential hybrid approach. Experimental investigations, including a co ..."
Abstract

Cited by 3 (3 self)
 Add to MetaCart
(Show Context)
We present a Lagrangian decomposition approach for the Knapsack Constrained Maximum Spanning Tree problem yielding upper bounds as well as heuristic solutions. This method is further combined with an evolutionary algorithm to a sequential hybrid approach. Experimental investigations, including a comparison to a previously suggested simpler Lagrangian relaxation based method, document the advantages of the new approach. Most of the upper bounds derived by Lagrangian decomposition are optimal, and together with the evolutionary algorithm, large instances with up to 12000 nodes can be either solved to provable optimality or with a very small remaining gap in reasonable time.
The complexity of implicit and spaceefficient priority queues
 Proceedings of the 9th Workshop on Algorithms and Data Structures, Lecture
"... Abstract. In this paper we study the timespace complexity of implicit priority queues supporting the decreasekey operation. Our first result is that by using one extra word of storage it is possible to match the performance of Fibonacci heaps: constant amortized time for insert and decreasekey and ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
Abstract. In this paper we study the timespace complexity of implicit priority queues supporting the decreasekey operation. Our first result is that by using one extra word of storage it is possible to match the performance of Fibonacci heaps: constant amortized time for insert and decreasekey and logarithmic time for deletemin. Our second result is a lower bound showing that that one extra word really is necessary. We reduce the decreasekey operation to a cellprobe type game called the Usher's Problem, where one must maintain a simple data structure without the aid of any auxiliary storage.
Violation heaps: A better substitute for Fibonacci heaps
, 2008
"... We give a priority queue that achieves the same amortized bounds as Fibonacci heaps. Namely, findmin requires O(1) worstcase time, insert, meld and decreasekey require O(1) amortized time, and deletemin requires O(log n) amortized time. Our structure is simple and promises a more efficient pract ..."
Abstract

Cited by 3 (0 self)
 Add to MetaCart
(Show Context)
We give a priority queue that achieves the same amortized bounds as Fibonacci heaps. Namely, findmin requires O(1) worstcase time, insert, meld and decreasekey require O(1) amortized time, and deletemin requires O(log n) amortized time. Our structure is simple and promises a more efficient practical behavior compared to any other known Fibonaccilike heap.