Showing papers by "Gerth Stølting Brodal published in 2013"
01 Jan 2013
TL;DR: This paper tries to list some of the directions research on priority queues has taken in the last 50 years.
Abstract: Back in 1964 Williams introduced the binary heap as a basic priority queue data structure supporting the operations Insert and ExtractMin in logarithmic time. Since then numerous papers have been published on priority queues. This paper tries to list some of the directions research on priority queues has taken the last 50 years.
34 citations
06 Jan 2013
TL;DR: This paper shows how to compute the triplet distance in time O(n log n) and the quartet distance inTime O(dn log n), where d is the maximal degree of any node in the two trees, and presents efficient algorithms for computing these distances.
Abstract: The triplet and quartet distances are distance measures to compare two rooted and two unrooted trees, respectively. The leaves of the two trees should have the same set of n labels. The distances are defined by enumerating all subsets of three labels (triplets) and four labels (quartets), respectively, and counting how often the induced topologies in the two input trees are different. In this paper we present efficient algorithms for computing these distances. We show how to compute the triplet distance in time O(n log n) and the quartet distance in time O(dn log n), where d is the maximal degree of any node in the two trees. Within the same time bounds, our framework also allows us to compute the parameterized triplet and quartet distances, where a parameter is introduced to weight resolved (binary) topologies against unresolved (non-binary) topologies. The previous best algorithm for computing the triplet and parameterized triplet distances have O(n2) running time, while the previous best algorithms for computing the quartet distance include an O(d9n log n) time algorithm and an O(n2.688) time algorithm, where the latter can also compute the parameterized quartet distance. Since d ≤ n, our algorithms improve on all these algorithms.
26 citations
TL;DR: A series of algorithmic improvements that have been used during the last decade to develop more efficient algorithms are reviewed by exploiting two different strategies for this; one based on dynamic programming and another based on coloring leaves in one tree and updating a hierarchical decomposition of the other.
Abstract: Distance measures between trees are useful for comparing trees in a systematic manner, and several different distance measures have been proposed. The triplet and quartet distances, for rooted and unrooted trees, respectively, are defined as the number of subsets of three or four leaves, respectively, where the topologies of the induced subtrees differ. These distances can trivially be computed by explicitly enumerating all sets of three or four leaves and testing if the topologies are different, but this leads to time complexities at least of the order n3 or n4 just for enumerating the sets. The different topologies can be counte dimplicitly, however, and in this paper, we review a series of algorithmic improvements that have been used during the last decade to develop more efficient algorithms by exploiting two different strategies for this; one based on dynamic programming and another based oncoloring leaves in one tree and updating a hierarchical decomposition of the other.
18 citations
Posted Content•
TL;DR: This work considers the problem of preprocessing a set P of n points into a space efficient static data structure supporting orthogonal skyline counting queries and presents a data structure for storing n points with integer coordinates having query time O(n) and space usage O( n) words.
Abstract: The skyline of a set of points in the plane is the subset of maximal points, where a point $(x,y)$ is maximal if no other point $(x',y')$ satisfies $x'\ge x$ and $y'\ge Y$. We consider the problem of preprocessing a set $P$ of $n$ points into a space efficient static data structure supporting orthogonal skyline counting queries, i.e. given a query rectangle $R$ to report the size of the skyline of $P$ intersected with $R$. We present a data structure for storing n points with integer coordinates having query time $O(\lg n/\lg\lg n)$ and space usage $O(n)$. The model of computation is a unit cost RAM with logarithmic word size. We prove that these bounds are the best possible by presenting a lower bound in the cell probe model with logarithmic word size: Space usage $n\lg^{O(1)} n$ implies worst case query time $\Omega(\lg n/\lg\lg n)$.
11 citations
02 Sep 2013
TL;DR: This work considers the space complexity of the encoding variant of the problem where queries have access to the constructed data structure but can not access the input matrix A, i.e. all information must be encoded in the data structure.
Abstract: In the two-dimensional range minimum query problem an input matrix A of dimension m ×n, m ≤ n, has to be preprocessed into a data structure such that given a query rectangle within the matrix, the position of a minimum element within the query range can be reported We consider the space complexity of the encoding variant of the problem where queries have access to the constructed data structure but can not access the input matrix A, ie all information must be encoded in the data structure Previously it was known how to solve the problem with space O(mn min {m,logn}) bits (and with constant query time), but the best lower bound was Ω(mnlogm) bits, ie leaving a gap between the upper and lower bounds for non-quadratic matrices We show that this space lower bound is optimal by presenting an encoding scheme using O(mnlogm) bits We do not consider query time
10 citations
21 Jan 2013
TL;DR: An algorithm is presented that computes the triplet distance between two rooted binary trees in time O (n log2n) and it is shown that this algorithm can be implemented to give a competitive wall-time running time.
Abstract: The triplet distance is a distance measure that compares two rooted trees on the same set of leaves by enumerating all sub-sets of three leaves and counting how often the induced topologies of the tree are equal or different. We present an algorithm that computes the triplet distance between two rooted binary trees in time O (n log2 n). The algorithm is related to an algorithm for computing the quartet distance between two unrooted binary trees in time O (n log n). While the quartet distance algorithm has a very severe overhead in the asymptotic time complexity that makes it impractical compared to O (n2) time algorithms, we show through experiments that the triplet distance algorithm can be implemented to give a competitive wall-time running time.
10 citations
02 Sep 2013
TL;DR: Here the case where the raster \(\mathcal{G}\) is so large that it does not fit in the main memory of the computer is considered.
Abstract: In many scientific applications it is required to reconstruct a raster dataset many times, each time using a different resolution. This leads to the following problem; let \(\mathcal{G}\) be a raster of \(\sqrt{N}\) x \(\sqrt{N}\) cells. We want to compute for every integer 2 \(\leq \mu \leq \sqrt{N}\) a raster \(\mathcal{G}_\mu\) of [\(\sqrt{N}/\mu\)] x [\(\sqrt{N}/\mu\)] cells where each cell of \(\mathcal{G}_\mu\) stores the average of the values of μ x μ cells of \(\mathcal{G}\). Here we consider the case where \(\mathcal{G}\) is so large that it does not fit in the main memory of the computer.
1 citations