Jyrki Katajainen

A Reliable Randomized Algorithm for the Closest-Pair Problem

The following two computational problems are studied:Duplicate grouping:Assume thatnitems are given, each of which is labeled by an integer key from the set {0,?,U?1}. Store the items in an array of sizensuch that items with the same key occupy a contiguous segment of the array.Closest pair:Assume that a multiset ofnpoints in thed-dimensional Euclidean space is given, whered?1 is a fixed integer. Each point is represented as ad-tuple of integers in the range {0,?,U?1} (or of arbitrary real numbers). Find a closest pair, i.e., a pair of points whose distance is minimal over all such pairs.In 1976, Rabin described a randomized algorithm for the closest-pair problem that takes linear expected time. As a subroutine, he used a hashing procedure whose implementation was left open. Only years later randomized hashing schemes suitable for filling this gap were developed.In this paper, we return to Rabins classic algorithm to provide a fully detailed description and analysis, thereby also extending and strengthening his result. As a preliminary step, we study randomized algorithms for the duplicate-grouping problem. In the course of solving the duplicate-grouping problem, we describe a new universal class of hash functions of independent interest.It is shown that both of the foregoing problems can be solved by randomized algorithms that useO(n) space and finish inO(n) time with probability tending to 1 asngrows to infinity. The model of computation is a unit-cost RAM capable of generating random numbers and of performing arithmetic operations from the set {+,?,?,div,log2,exp2}, wheredivdenotes integer division andlog2andexp2are the mappings from N to N?{0} withlog2(m)=?log2m? andexp2(m)=2mfor allm?N. If the operationslog2andexp2are not available, the running time of the algorithms increases by an additive term ofO(loglogU). All numbers manipulated by the algorithms consist ofO(logn+logU) bits.The algorithms for both of the problems exceed the time boundO(n) orO(n+loglogU) with probability 2?n?(1). Variants of the algorithms are also given that use onlyO(logn+logU) random bits and have probabilityO(n??) of exceeding the time bounds, where ??1 is a constant that can be chosen arbitrarily.The algorithms for the closest-pair problem also works if the coordinates of the points are arbitrary real numbers, provided that the RAM is able to perform arithmetic operations from {+,?,?,div} on real numbers, whereadivbnow means ?a/b?. In this case, the running time isO(n) withlog2andexp2andO(n+loglog(?max/?max)) without them, where ?maxis the maximum and ?minis the minimum distance between any two distinct input points.

Multipartite priority queues

We introduce a framework for reducing the number of element comparisons performed in priority-queue operations. In particular, we give a priority queue which guarantees the worst-case cost of <i>O</i>(1) per minimum finding and insertion, and the worst-case cost of <i>O</i>(log <i>n</i>) with at most log <i>n</i> + <i>O</i>(1) element comparisons per deletion, improving the bound of 2 log <i>n</i> + <i>O</i>(1) known for binomial queues. Here, <i>n</i> denotes the number of elements stored in the data structure prior to the operation in question, and log <i>n</i> equals log₂(max {2, n}). As an immediate application of the priority queue developed, we obtain a sorting algorithm that is optimally adaptive with respect to the inversion measure of disorder, and that sorts a sequence having <i>n</i> elements and <i>I</i> inversions with at most <i>n</i> log (<i>I</i>/<i>n</i>) + <i>O</i>(<i>n</i>) element comparisons.

In-Place Calculation of Minimum-Redundancy Codes

The optimal prefixfree code problem is to determine, for a given array p=[p i ¦i∈{1...n}] of n weights, an integer array l= [l i ¦∈{1...n}] of n codeword lengths such that \(\sum\nolimits_{i = 1}^n {2^{ - l_i } \leqslant 1}\)and \(\sum\nolimits_{i = 1}^n {p_i l_i }\)is minmized. Huffmans famous greedy algorithm solves this problem in O(n log n) time, if p is unsorted; and can be implemented to execute in O(n) time, if the input array p is sorted. Here we consider the space requirements of the greedy method. We show that if p is sorted then it is possible to calculate the array l in-place, with l i overwriting p i , in O(n) time and using O(1) additional space. The new implementation leads directly to an O(n log n)-time and n + O(1) words of extra space implementation for the case when p is not sorted. The proposed method is simple to implement and executes quickly.

Worst-case efficient external-memory priority queues

A priority queue Q is a data structure that maintains a collection of elements, each element having an associated priority drawn from a totally ordered universe, under the operations Insert, which inserts an element into Q, and DeleteMin, which deletes an element with the minimum priority from Q. In this paper a priority-queue implementation is given which is efficient with respect to the number of block transfers or I/Os performed between the internal and external memories of a computer. Let B and M denote the respective capacity of a block and the internal memory measured in elements. The developed data structure handles any intermixed sequence of Insert and DeleteMin operations such that in every disjoint interval of B consecutive priorityqueue operations at most clogM/B N/M I/Os are performed, for some positive constant c. These I/Os are divided evenly among the operations: if B ≥ clogM/B N/M, one I/O is necessary for every B/(clogM/B N/M)th operation and if B < clogM/B N/M, c/B log M/B N/M I/Os are performed per every operation. Moreover, every operation requires O(log2 N) comparisons in the worst case. The best earlier solutions can only handle a sequence of S operations with O(σ i=1 S 1/B log M/B Ni/M) I/Os, where N i denotes the number of elements stored in the data structure prior to the ith operation, without giving any guarantee for the performance of the individual operations.

Comparison of algorithms for standard median filtering

Standard median filtering that is searched repeatedly for a median from a sample set which changes only slightly between the subsequent searches is discussed. Several well-known methods for solving this running median problem are reviewed, the (asymptotical) time complexities of the methods are analyzed, and simple variants are proposed which are especially suited for small sample sets, a frequent situation. Although the discussion is restricted to the one-dimensional case, the ideas are easily extended to higher dimensions. >

Space-efficient planar convex hull algorithms

A space-efficient algorithm is one in which the output is given in the same location as the input and only a small amount of additional memory is used by the algorithm. We describe four space-efficient algorithms for computing the convex hull of a planar point set.

Asymptotically efficient in-place merging

Two linear-time algorithms for in-place/ merging are presented. Both algorithms perform at most m(t+1)+n/2t+o(m) comparisons, where m and n are the sizes of the input sequences, m⩽n, and t=⌊log2(n/m)⌋. The first algorithm is for unstable/ merging and it carries out no more than 3(n+m)+o(m) element moves. The second algorithm is for stable/ merging and it accomplishes at most 5n+12m+o(m) moves.

Stable minimum space partitioning in linear time

In the stable0–1 sorting problem the task is to sort an array ofn elements with two distinct values such that equal elements retain their relative input order. Recently, Munro, Raman and Salowe gave an algorithm which solves this problem inO(n log*n) time and constant extra space. We show that by a modification of their method the stable0–1 sorting is possible inO(n) time andO(1) extra space. Stable three-way partitioning can be reduced to stable0–1 sorting. This immediately yields a stable minimum space quicksort, which sorts multisets in asymptotically optimal time with high probability.

Heaps and heapsort on secondary storage

A heap structure designed for secondary storage is suggested that tries to make the best use of the available buffer space in primary memory. The heap is a complete multi-way tree, with multi-page blocks of records as nodes, satisfying a generalized heap property. A special feature of the tree is that the nodes may be partially filled, as in B-trees. The structure is complemented with priority-queue operations insert and delete-max. When handling a sequence of S operations, the number of page transfers performed is shown to be 0(x:=,( l/P) logCMip,(N#‘)), where P denotes the number of records fitting into a page, M the capacity of the buffer space in records, and Ni the number of records in the heap prior to the ith operation (assuming P 2 1 and S >M >c P, where c is a small positive constant). The number of comparisons required when handling the sequence is O(~~=, log, Ni). Using the suggested data structure we obtain an optimal external heapsort that performs O((NIp) log CM,pj(N/P)) page transfers and O(N log, N) comparisons in the worst case when sorting N records. @ 1999 Elsevier Science B.V. All rights reserved.

Computing relative neighbourhood graphs in the plane

Abstract The relative neighbourhood graph (RNG) of a set of N points connects the relative neighbours, i.e. a pair of points is connected by an edge if those points are at least as close to each other as to any other point. The paper presents two new algorithms for constructing RNG in two-dimensional Euclidean space. The method is to determine a supergraph for RNG which can then be thinned efficiently from the extra edges. The first algorithm is simple, and works in O ( N 2 ) time. The worst case running time of the second algorithm is also O ( N 2 ), but its average case running time is O ( N ) for points from a homogeneous planar Poisson point process. Experimental tests have shown the usefulness of the approach.