# on compressing permutations and adaptive sorting

Post on 25-Dec-2016

231 views

Embed Size (px)

TRANSCRIPT

Theoretical Computer Science 513 (2013) 109123

Contents lists available at ScienceDirect

Theoretical Computer Science

www.elsevier.com/locate/tcs

On compressing permutations and adaptive sorting

Jrmy Barbay 1, Gonzalo Navarro ,2

Dept. of Computer Science, University of Chile, Chile

a r t i c l e i n f o a b s t r a c t

Article history:Received 6 May 2013Received in revised form 29 September2013Accepted 7 October 2013Communicated by G.F. Italiano

Keywords:CompressionPermutationsSuccinct data structuresAdaptive sorting

We prove that, given a permutation over [1..n] formed of nRuns sorted blocks of sizesgiven by the vector R = r1, . . . , rnRuns, there exists a compressed data structure encoding in n(1 +H(R)) = n +nRunsi=1 ri log2 nri n(1 + log2 nRuns) bits while supporting accessto the values of () and 1() in time O(lognRuns/ log log n) in the worst case andO(H(R)/ log log n) on average, when the argument is uniformly distributed over [1..n].This data structure can be constructed in time O(n(1 +H(R))), which yields an improvedadaptive sorting algorithm. Similar results on compressed data structures for permutationsand adaptive sorting algorithms are proved for other preorder measures of practical andtheoretical interest.

2013 Elsevier B.V. All rights reserved.

1. Introduction

Permutations of the integers [1..n] = {1, . . . ,n} are a fundamental mathematical structure, and a basic building blockfor the succinct encoding of integer functions [39], strings [30,22,25,2,34,14], binary relations [9], and geometric grids [13],among others. A permutation can be trivially encoded in nlg n bits, which is within O(n) bits of the information theorylower bound of lg(n!) bits, where lg x = log2 x denotes the logarithm in base two.

Efficient computation for both the value (i) at any point i [1..n] of the permutation, and for the position 1( j) ofany value j [1..n] (i.e., the value of the inverse permutation) is essential in most of those applications. A trivial solutionis to store explicitly both and 1, using a total of 2nlg n bits. Munro et al. [39] proposed three nontrivial alternatives.The first consists in plainly representing in nlg n bits (hence supporting the operator () in constant time) and addinga small structure of n lg n extra bits in order to support the operator 1() in time O(1/). The second solution uses theprevious one to encode another permutation, the one mapping the original permutation to a cycle representation, whichyields support for any positive or negative power of (), k(i) for any k Z. The third solution uses less space (onlyO(n) extra bits, as opposed to n lg n) but supports the operator k( j) for any value of k and j in higher time, withinO(log n/ log log n). Each of those solutions uses at least n log2 n bits to encode the permutation itself.

The lower bound of lg(n!) bits to represent any permutation yields a lower bound of (n log n) comparisons to sort a per-mutation in the comparison model, in the worst case over all permutations of n elements. A large body of research has beendedicated to finding better sorting algorithms that can take advantage of specificities of certain families of permutations.Some examples are permutations composed of a few sorted blocks (also called runs) [35] (e.g., (1,3,5,7,9,2,4,6,8,10)or (6,7,8,9,10,1,2,3,4,5)), or permutations containing few sorted subsequences [33] (e.g., (1,6,2,7,3,8,4,9,5,10)). Al-gorithms performing possibly o(n log n) comparisons on such permutations, yet still O(n log n) comparisons in the worst

An early version of this article appeared in Proc. STACS 2009 [10].

* Corresponding author.E-mail addresses: jbarbay@dcc.uchile.cl (J. Barbay), gnavarro@dcc.uchile.cl (G. Navarro).

1 Partially funded by Fondecyt Grant 1120054, Chile.2 Partially funded by Millennium Nucleus Information and Coordination in Networks ICM/FIC P10-024F, Chile.

0304-3975/$ see front matter 2013 Elsevier B.V. All rights reserved.http://dx.doi.org/10.1016/j.tcs.2013.10.019

http://dx.doi.org/10.1016/j.tcs.2013.10.019http://www.ScienceDirect.com/http://www.elsevier.com/locate/tcsmailto:jbarbay@dcc.uchile.clmailto:gnavarro@dcc.uchile.clhttp://dx.doi.org/10.1016/j.tcs.2013.10.019http://crossmark.crossref.org/dialog/?doi=10.1016/j.tcs.2013.10.019&domain=pdf110 J. Barbay, G. Navarro / Theoretical Computer Science 513 (2013) 109123

case, are achievable and preferable if those permutations arise with sufficient frequency. Other examples are classes ofpermutations whose structure makes them interesting for applications; see the seminal paper of Mannila [35], and thesurvey of Moffat and Petersson [37].

Each sorting algorithm in the comparison model yields an encoding scheme for permutations: the result of all the com-parisons performed uniquely identifies the permutation sorted, and hence encodes it. Since an adaptive sorting algorithmperforms o(n log n) comparisons on a class of easy permutations, each adaptive algorithm yields a compression scheme forpermutations, at the cost of losing a constant factor on the complementary class of hard permutations. Yet such compres-sion schemes do not necessarily support efficiently the computation of arbitrary (i) values, nor the inverse permutationvalues 1( j).

It is natural to ask whether it is possible to compress a permutation [37] while at the same time supporting efficientaccess to and its inverse [39]. To the best of our knowledge, such a representation had not been described till now. In thispaper we describe a whole family of such compressed data structures, inspired by and improving upon the MergeSortfamily of adaptive sorting algorithms [35]. All of them take advantage of permutations composed of a small number ofmonotone subsequences, and support the operators () and 1() efficiently, taking less time on the more compressiblepermutations.

Our central result (Theorem 3) is a compressed data structure based on the decomposition of a permutation intoruns, that is, monotone subsequences of consecutive positions. If is formed by nRuns runs of sizes given by the vectorR = r1, . . . , rnRuns, our data structure encodes it in n(1 +H(R)) = n + nRunsi=1 ri lg nri n(1 + lgnRuns) bits and supportsaccess to the values of () and 1() in time O(lognRuns/ log log n) in the worst case and O(H(R)/ log log n) on average,when the argument is uniformly distributed over [1..n]. The construction of this data structure yields an improved adaptivesorting algorithm running in time O(n(1 +H(R))). Similar data structures and adaptive sorting algorithms are obtained, viareductions, for other preorder measures of practical and theoretical interest, such as strict runs, a particular case of runswith consecutive values, and shuffled sequences, monotone subsequences of not necessarily consecutive positions. Thoseresults have applications to the indexing of natural language text collections, the support of compressed suffix arrays, andthe representation of strings supporting operations access, rank, and select (Theorem 8). The latter result improves uponthe state of the art [16,23] in the average case when the queries are uniformly distributed, while retaining the space andworst-case performance of the previous solutions.

2. Basic concepts and previous work

For completeness, we review here some basic notions and techniques about entropy (Section 2.1), Huffman codes (Sec-tion 2.2), data structures on sequences (Section 2.3) and adaptive sorting algorithms (Section 2.4). Readers already familiarwith those notions can safely skip this section.

2.1. Entropy

We define the entropy of a distribution [15], a measure that will be useful to evaluate compressibility results.

Definition 1. The entropy of a sequence of positive integers X = n1,n2, . . . ,nr adding up to n is H(X) = ri=1 nin lg nni . Byconcavity of the logarithm, it holds that (r 1) lg n nH(X) n lg r and that H(n1,n2, . . .nr) >H(n1+n2, . . . ,nr).

Here X = n1,n2, . . . ,nr is a distribution and H(X) measures how even is it. H(X) is maximal (lg r) when all ni = n/rand minimal ( r1n lg n + nr+1n lg nnr+1 ) when they are most skewed (X = 1,1, . . . ,1,n r + 1).

This measure is related to the entropy of random variables and of sequences as follows. If a random variable P takes thevalue i with probability ni/n, for 1 i r, then its entropy is H(n1,n2, . . . ,nr). Similarly, if a string S[1..n] contains nioccurrences of character ci , then its empirical zero-order entropy is H0(S) =H(n1,n2, . . . ,nr).

H(X) is then a lower bound to the average number of bits needed to encode an instance of P , or to encode a characterof S (if we model S statistically with a zero-order model, that is, ignoring the context of characters).

2.2. Huffman codes

Given symbols [1..r] with frequencies X = n1,n2, . . . ,nr adding up to n, Huffman [28] described how to build anoptimal prefix-free code for them. His algorithm can be implemented in time O(r log r). If i is the bit length of the codeassigned to the ith symbol, then L = ini is minimal and L < n(1 + H(X)). For example, given a string S[1..n] overalphabet [1..r], with symbol frequencies X[1..r], one can compress S by concatenating the codewords of the successivesymbols S[i], achieving total length L < n(1 +H0(S)). (One also has to encode the usually negligible codebook of O(r log r)bits.)

The algorithm to build the optimal prefix-free code starts with a forest of r leaves corresponding to the frequencies{n1,n2, . . . ,nr}, and outputs a binary trie with those leaves, in some order. This so-called Huffman tree describes the optimalencoding as follows: The sequence of left/right choices (interpreted as 0/1) in the path from the root to each leaf is theprefix-free encoding of that leaf, of length i equal to the leaf depth.