An approximation to the greedy algorithm for differential compression

Génération aléatoire uniforme de mots de langages rationnels

A simple algorithm is given which takes an arbitrary binary search tree and rebalances it to form another of optimal shape, using time linear in the number of nodes and only a constant amount of space (beyond that used to store the initial tree). This algorithm is therefore optimal in its use of both time and space. Previous algorithms were optimal in at most one of these two measures, or were not applicable to all binary search trees. When the nodes of the tree are stored in an array, a simple addition to this algorithm results in the nodes being stored in sorted order in the initial portion of the array, again using linear time and constant space.

Given a sequence T = t0t1 . . . tn-1 of size n = |T|, with symbols from a fixed alphabet Σ, (|Σ| ≤ n), the suffix array provides a listing of all the suffixes of T in a lexicographic order. Given T, the suffix sorting problem is to construct its suffix array. The direct suffix sorting problem is to construct the suffix array of T directly without using the suffix tree data structure. While algorithims for linear time, linear space direct suffix sorting have been proposed, the actual constant in the linear space is still a major concern, given that the applications of suffix trees and suffix arrays (such as in whole-genome analysis) often involve huge data sets. In this work, we reduce the gap between current results and the minimal space requirement. We introduce an algorithm for the direct suffix sorting problem with worst case time complexity in O(n), requiring only (1 2 3 n log n - n log | ∑ |+O(1)) bits in memory space. This implies 5 2 3 n+O(1) bytes for total space requirment, (including space for both the output suffix array and the input sequence T) assuming n ≤ 2 32 ,| ∑ |≤256 , and 4 bytes per integer. The basis of our algorithm is an extension of Shannon-Fano-Elias codes used in source coding and information theory. This is the first time information-theoretic methods have been used as the basis for solving the suffix sorting problem.

Approximating shortest superstrings with constraints

The suffix array is a fundamental data structure to support string analysis efficiently. It took about 26 years for the sequential suffix array construction algorithm to achieve $$\mathcal {O}(n)$$ time complexity and in-place sorting. In this paper, we develop the D-Limited Parallel Induce (DLPI) algorithm, the first $$\mathcal {O}(\frac{n}{p})$$ time parallel suffix array construction algorithm. The basic idea of DLPI includes two aspects: dividing the $$\mathcal {O}(n)$$ size problem into p reduced sub-problems with size $$\mathcal {O}(\frac{n}{p})$$ so we can handle them on p processors in parallel; developing an efficient parallel induce sorting method to achieve correct order for all the reduced sub-problems. The complete algorithm description is given to show the implementation method of the proposed idea. The time and space complexity analysis and proof are also given to show the correctness and efficiency of the proposed algorithm. The proposed DLPI algorithm can handle large strings with scalable performance.

Stable unmerging in linear time and constant space

Buffer insertion and wire sizing are critical in deep submicron VLSI design. This paper studies the problem of constructing routing trees with simultaneous buffer insertion and wire sizing in the presence of routing and buffer obstacles. No previous algorithms consider all these factors simultaneously. Previous dynamic programming based algorithm is first extended to solve the problem. However, with the size of routing graph increasing and with wire sizing taken into account, the time and space requirement increases enormously. Then a new approach is proposed to formulate the problem as a series of graph problems. The routing tree solution is obtained by finding shortest paths in a series of graphs. In the new approach, wire sizing can be handled almost without any additional time and space requirement, Moreover, the time and space requirement is only polynomial in terms of the size of routing graph. Our algorithm differs from traditional dynamic programming, and is capable of addressing the problem of inverter insertion and sink polarity. Both theoretical and experimental results show that the graph-based algorithm outperforms the DP-based algorithm by a large margin. We also propose a hierarchical approach to construct routing tree for a large number of sinks.

Constructing a binary tree from its traversals by reversible recursion and iteration

Deterministic sorting in O( nloglog n) time and linear space

Keywords: Lempel-Ziv, Lossless Data Compression, Suffix Arrays, Suffix Tre es, String Matching.Abstract: Lossless compression algorithms of the Lempel-Ziv (LZ) family are widely used in a variety of applications.The LZ encoder and decoder exhibit a high asymmetry, regarding time and memory requirements, with theformer being much more demanding. Several techniques have been used to speed up the encoding process;among them is the use of suffix trees. In this paper, we explore the use of a simple data structure, namedsuffix array , to hold the dictionary of the LZ encoder, and propose an algorithm to search the dictionary.A comparison with the suffix tree based LZ encoder is carried out, showin g that the compression ratios areroughly the same. The ammount of memory required by the suffix arra y is fixed, being much lower than thevariable memory requirements of the suffix tree encoder, which depen ds on the text to encode. We concludethat suffix arrays are a very interesting option regarding the tradeoff b etween time, memory, and compressionratio, when compared with suffix trees, that make them preferable in som e compression scenarios.

We present the family of RedBlue algorithms, a collection of universal wait-free constructions for linearizable shared objects in an asynchronous shared-memory distributed system with n processes. The algorithms are adaptive and improve upon previous algorithms in terms of their time and/or space complexity. The first of the algorithms achieves better time complexity than all previously presented algorithms but it is impractical since it uses large LL/SC registers. This algorithm comprises the keystone for the design of the other RedBlue algorithms which are of practical interest. The second algorithm significantly reduces the size of the required registers and it is therefore practical in many cases. The last two algorithms work efficiently for large objects improving previous universal constructions for large objects presented by Anderson and Moir (PODC 1995).

A new version of the nearest-neighbour approximating and eliminating search algorithm (AESA) with linear preprocessing time and memory requirements

Optimizing strategies for post-disaster reconstruction of school systems

ldquoULTRA GRIDSECrdquo is a high performance symmetric key cryptography schema used to increase the performance of symmetric key encryption algorithms like DES and TDES by decreasing their execution time and increasing their security by using compression and multithreading techniques and other enhancement points. In this paper we enhancing the performance of a ldquoULTRA GRIDSECrdquo by using a pure peer-to-peer computational grid middleware called (HIMAN) that we developed before. ldquoULTRA GRIDSECrdquo performance accelerated by about 254.8% when it was applied as an application for ldquoHIMANldquo middleware for file with size 55 MB and 1 MB Block Size, and accelerated by 431.2% for file with size 110 MB and 10 MB Block Size so every time the size of file is large and choosing the suitable block size and suitable number of threads this can cause a great acceleration for the schema performance regarding to machines capabilities of the running middleware. After that we compared the performance of the Enhanced ldquoULTRA GRIDSECrdquo with a developed schema called ldquoGRIDCRYPTrdquo developed by Melbourne University in Australia and run over their middleware called Alchemi, so for file with size 55 MB and 1 MB Block Size and using 4 workers, ldquoULTRA GRIDSECrdquo Performance is faster by about 445.37% than the ldquoGRIDCRYPTrdquo Schema, and for file with size 110 MB and 10 MB Block Size and using 4 workers, ldquoULTRA GRIDSECrdquo Performance is faster by about 708.69% than the ldquoGRIDCRYPTrdquo Schema. An analysis and results of this schema and comparison of this scheme performance with another existing schema is presented in this paper.

BackgroundAn absent word of a word y of length n is a word that does not occur in y. It is a minimal absent word if all its proper factors occur in y. Minimal absent words have been computed in genomes of organisms from all domains of life; their computation also provides a fast alternative for measuring approximation in sequence comparison. There exists an tttttttmathcal {O}(n)tttttt-time and tttttttmathcal {O}(n)tttttt-space algorithm for computing all minimal absent words on a fixed-sized alphabet based on the construction of suffix automata (Crochemore et al., 1998). No implementation of this algorithm is publicly available. There also exists an tttttttmathcal {O}(n^{2})tttttt-time and tttttttmathcal {O}(n)tttttt-space algorithm for the same problem based on the construction of suffix arrays (Pinho et al., 2009). An implementation of this algorithm was also provided by the authors and is currently the fastest available.ResultsOur contribution in this article is twofold: first, we bridge this unpleasant gap by presenting an tttttttmathcal {O}(n)tttttt-time and tttttttmathcal {O}(n)tttttt-space algorithm for computing all minimal absent words based on the construction of suffix arrays; and second, we provide the respective implementation of this algorithm. Experimental results, using real and synthetic data, show that this implementation outperforms the one by Pinho et al. The open-source code of our implementation is freely available at http://github.com/solonas13/maw.ConclusionsClassical notions for sequence comparison are increasingly being replaced by other similarity measures that refer to the composition of sequences in terms of their constituent patterns. One such measure is the minimal absent words. In this article, we present a new linear-time and linear-space algorithm for the computation of minimal absent words based on the suffix array.