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

tqDist: a library for computing the quartet and triplet distances between binary or general trees

Abstract: Summary: tqDist is a software package for computing the triplet and quartet distances between general rooted or unrooted trees, respectively. The program is based on algorithms with running time O(nlogn) for the triplet distance calculation and O(d·nlogn) for the quartet distance calculation, where n is the number of leaves in the trees and d is the degree of the tree with minimum degree. These are currently the fastest algorithms both in theory and in practice. Availability and Implementation: tqDist can be installed on Windows, Linux and Mac OS X. Doing this will install a set of command-line tools together with a Python module and an R package for scripting in Python or R. The software package is freely available under the GNU LGPL licence at http://birc.au.dk/software/tqDist.

Optimal Planar Orthogonal Skyline Counting Queries

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′ ≥ x and y′ ≥ 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 ∩ 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) words. 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 matching 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)\).

On the scalability of computing triplet and quartet distances

Abstract: In this paper we present an experimental evaluation of the algorithms by Brodal et al. [SODA 2013] for computing the triplet and quartet distance measures between two leaf labelled rooted and unrooted trees of arbitrary degree, respectively. The algorithms count the number of rooted tree topologies over sets of three leaves (triplets) and unrooted tree topologies over four leaves (quartets), respectively, that have different topologies in the two trees. The algorithms by Brodal et al. maintain a long sequence of variables (hundreds for quartets) for counting different cases to be considered by the algorithm, making it unclear if the algorithms would be of theoretical interest only. In our experimental evaluation of the algorithms the typical overhead per node is about 2KB and 10KB per node in the input trees for triplet and quartet computations, respectively. This allows us to compute the distance measures for trees with up to millions of nodes. The limiting factor is the amount of memory available. With 31 GB of memory all our input instances can be solved within a few minutes. In the algorithm by Brodal et al. a few choices were made, where alternative solutions possibly could improve the algorithm, in particular for quartet distance computations. For quartet computations we expand the algorithm to also consider alternative computations, and make two observations: First we observe that the running time can be improved from O(max(d1, d2)·n·lg n) to O(min(d1, d2)·n·lg n), where n is the number of leaves in the two trees, and d1 and d2 are the maximum degrees of the nodes in the two trees, respectively. Secondly, by taking a different approach to counting the number of disagreeing quartets we can reduce the number of calculations needed to calculate the quartet distance, improving both the running time and the space requirement by our algorithm by a constant factor.

Expected Linear Time Sorting for Word Size Ω(log2n loglogn)

Abstract: Sorting n integers in the word-RAM model is a fundamental problem and a long-standing open problem is whether integer sorting is possible in linear time when the word size is ω(logn). In this paper we give an algorithm for sorting integers in expected linear time when the word size is Ω(log2 n loglogn). Previously expected linear time sorting was only possible for word size Ω(log2 + e n). Part of our construction is a new packed sorting algorithm that sorts n integers of w/b-bits packed in \({\mathcal O}(n/b)\) words, where b is the number of integers packed in a word of size w bits. The packed sorting algorithm runs in expected \({\mathcal O}(\tfrac{n}{b}(\log n + \log^2 b))\) time.