178 research outputs found
Randomized QuickSort and the Entropy of the Random Source
The worst-case complexity of an implementation of Quicksort depends on the random number generator that is used to select the pivot elements. In this paper we estimate the expected number of comparisons of Quicksort as a function in the entropy of the random source. We give upper and lower bounds and show that the expected number of comparisons increases from to , if the entropy of the random source is bounded. As examples we show explicit bounds for distributions with bounded min-entropy and the geometrical distribution
The Entropy of Backwards Analysis
Backwards analysis, first popularized by Seidel, is often the simplest most
elegant way of analyzing a randomized algorithm. It applies to incremental
algorithms where elements are added incrementally, following some random
permutation, e.g., incremental Delauney triangulation of a pointset, where
points are added one by one, and where we always maintain the Delauney
triangulation of the points added thus far. For backwards analysis, we think of
the permutation as generated backwards, implying that the th point in the
permutation is picked uniformly at random from the points not picked yet in
the backwards direction. Backwards analysis has also been applied elegantly by
Chan to the randomized linear time minimum spanning tree algorithm of Karger,
Klein, and Tarjan.
The question considered in this paper is how much randomness we need in order
to trust the expected bounds obtained using backwards analysis, exactly and
approximately. For the exact case, it turns out that a random permutation works
if and only if it is minwise, that is, for any given subset, each element has
the same chance of being first. Minwise permutations are known to have
entropy, and this is then also what we need for exact backwards
analysis.
However, when it comes to approximation, the two concepts diverge
dramatically. To get backwards analysis to hold within a factor , the
random permutation needs entropy . This contrasts with
minwise permutations, where it is known that a approximation
only needs entropy. Our negative result for
backwards analysis essentially shows that it is as abstract as any analysis
based on full randomness
04421 Abstracts Collection -- Algebraic Methods in Computational Complexity
From 10.10.04 to 15.10.04, the Dagstuhl Seminar 04421
``Algebraic Methods in Computational Complexity\u27\u27
was held in the International Conference and Research Center (IBFI),
Schloss Dagstuhl.
During the seminar, several participants presented their current
research, and ongoing work and open problems were discussed. Abstracts of
the presentations given during the seminar as well as abstracts of
seminar results and ideas are put together in this paper. The first section
describes the seminar topics and goals in general.
Links to extended abstracts or full papers are provided, if available
Self-Improving Algorithms
We investigate ways in which an algorithm can improve its expected
performance by fine-tuning itself automatically with respect to an unknown
input distribution D. We assume here that D is of product type. More precisely,
suppose that we need to process a sequence I_1, I_2, ... of inputs I = (x_1,
x_2, ..., x_n) of some fixed length n, where each x_i is drawn independently
from some arbitrary, unknown distribution D_i. The goal is to design an
algorithm for these inputs so that eventually the expected running time will be
optimal for the input distribution D = D_1 * D_2 * ... * D_n.
We give such self-improving algorithms for two problems: (i) sorting a
sequence of numbers and (ii) computing the Delaunay triangulation of a planar
point set. Both algorithms achieve optimal expected limiting complexity. The
algorithms begin with a training phase during which they collect information
about the input distribution, followed by a stationary regime in which the
algorithms settle to their optimized incarnations.Comment: 26 pages, 8 figures, preliminary versions appeared at SODA 2006 and
SoCG 2008. Thorough revision to improve the presentation of the pape
Fast and Robust Vectorized In-Place Sorting of Primitive Types
Modern CPUs provide single instruction-multiple data (SIMD) instructions. SIMD instructions process several elements of a primitive data type simultaneously in fixed-size vectors. Classical sorting algorithms are not directly expressible in SIMD instructions. Accelerating sorting algorithms with SIMD instruction is therefore a creative endeavor. A promising approach for sorting with SIMD instructions is to use sorting networks for small arrays and Quicksort for large arrays. In this paper we improve vectorization techniques for sorting networks and Quicksort. In particular, we show how to use the full capacity of vector registers in sorting networks and how to make vectorized Quicksort robust with respect to different key distributions. To demonstrate the performance of our techniques we implement an in-place hybrid sorting algorithm for the data type int with AVX2 intrinsics. Our implementation is at least 30% faster than state-of-the-art high-performance sorting alternatives
- …