6,617 research outputs found
Faster Fully-Dynamic Minimum Spanning Forest
We give a new data structure for the fully-dynamic minimum spanning forest
problem in simple graphs. Edge updates are supported in
amortized time per operation, improving the amortized bound of
Holm et al. (STOC'98, JACM'01). We assume the Word-RAM model with standard
instructions.Comment: 13 pages, 2 figure
Dynamic Ordered Sets with Exponential Search Trees
We introduce exponential search trees as a novel technique for converting
static polynomial space search structures for ordered sets into fully-dynamic
linear space data structures.
This leads to an optimal bound of O(sqrt(log n/loglog n)) for searching and
updating a dynamic set of n integer keys in linear space. Here searching an
integer y means finding the maximum key in the set which is smaller than or
equal to y. This problem is equivalent to the standard text book problem of
maintaining an ordered set (see, e.g., Cormen, Leiserson, Rivest, and Stein:
Introduction to Algorithms, 2nd ed., MIT Press, 2001).
The best previous deterministic linear space bound was O(log n/loglog n) due
Fredman and Willard from STOC 1990. No better deterministic search bound was
known using polynomial space.
We also get the following worst-case linear space trade-offs between the
number n, the word length w, and the maximal key U < 2^w: O(min{loglog n+log
n/log w, (loglog n)(loglog U)/(logloglog U)}). These trade-offs are, however,
not likely to be optimal.
Our results are generalized to finger searching and string searching,
providing optimal results for both in terms of n.Comment: Revision corrects some typoes and state things better for
applications in subsequent paper
Exploiting non-constant safe memory in resilient algorithms and data structures
We extend the Faulty RAM model by Finocchi and Italiano (2008) by adding a
safe memory of arbitrary size , and we then derive tradeoffs between the
performance of resilient algorithmic techniques and the size of the safe
memory. Let and denote, respectively, the maximum amount of
faults which can happen during the execution of an algorithm and the actual
number of occurred faults, with . We propose a resilient
algorithm for sorting entries which requires time and uses safe memory words. Our
algorithm outperforms previous resilient sorting algorithms which do not
exploit the available safe memory and require time. Finally, we exploit our sorting algorithm for
deriving a resilient priority queue. Our implementation uses safe
memory words and faulty memory words for storing keys, and
requires amortized time for each insert and
deletemin operation. Our resilient priority queue improves the amortized time required by the state of the art.Comment: To appear in Theoretical Computer Science, 201
I/O-Efficient Dynamic Planar Range Skyline Queries
We present the first fully dynamic worst case I/O-efficient data structures
that support planar orthogonal \textit{3-sided range skyline reporting queries}
in \bigO (\log_{2B^\epsilon} n + \frac{t}{B^{1-\epsilon}}) I/Os and updates
in \bigO (\log_{2B^\epsilon} n) I/Os, using \bigO
(\frac{n}{B^{1-\epsilon}}) blocks of space, for input planar points,
reported points, and parameter . We obtain the result
by extending Sundar's priority queues with attrition to support the operations
\textsc{DeleteMin} and \textsc{CatenateAndAttrite} in \bigO (1) worst case
I/Os, and in \bigO(1/B) amortized I/Os given that a constant number of blocks
is already loaded in main memory. Finally, we show that any pointer-based
static data structure that supports \textit{dominated maxima reporting
queries}, namely the difficult special case of 4-sided skyline queries, in
\bigO(\log^{\bigO(1)}n +t) worst case time must occupy space, by adapting a similar lower bounding argument for
planar 4-sided range reporting queries.Comment: Submitted to SODA 201
The Logarithmic Funnel Heap: A Statistically Self-Similar Priority Queue
The present work contains the design and analysis of a statistically
self-similar data structure using linear space and supporting the operations,
insert, search, remove, increase-key and decrease-key for a deterministic
priority queue in expected O(1) time. Extract-max runs in O(log N) time. The
depth of the data structure is at most log* N. On the highest level, each
element acts as the entrance of a discrete, log* N-level funnel with a
logarithmically decreasing stem diameter, where the stem diameter denotes a
metric for the expected number of items maintained on a given level.Comment: 14 pages, 4 figure
An Efficient Implementation of the Robust Tabu Search Heuristic for Sparse Quadratic Assignment Problems
We propose and develop an efficient implementation of the robust tabu search
heuristic for sparse quadratic assignment problems. The traditional
implementation of the heuristic applicable to all quadratic assignment problems
is of O(N^2) complexity per iteration for problems of size N. Using multiple
priority queues to determine the next best move instead of scanning all
possible moves, and using adjacency lists to minimize the operations needed to
determine the cost of moves, we reduce the asymptotic complexity per iteration
to O(N log N ). For practical sized problems, the complexity is O(N)
- …