Auxiliary Data Structures Research Articles

The longest common subsequence problem revisited

This paper re-examines, in a unified framework, two classic approaches to the problem of finding a longest common subsequence (LCS) of two strings, and proposes faster implementations for both. Letl be the length of an LCS between two strings of lengthm andn ≥m, respectively, and let s be the alphabet size. The first revised strategy follows the paradigm of a previousO(ln) time algorithm by Hirschberg. The new version can be implemented in timeO(lm · min logs, logm, log(2n/m)), which is profitable when the input strings differ considerably in size (a looser bound for both versions isO(mn)). The second strategy improves on the Hunt-Szymanski algorithm. This latter takes timeO((r +n) logn), wherer≤mn is the total number of matches between the two input strings. Such a performance is quite good (O(n logn)) whenr∼n, but it degrades to Θ(mn logn) in the worst case. On the other hand the variation presented here is never worse than linear-time in the productmn. The exact time bound derived for this second algorithm isO(m logn +d log(2mn/d)), whered ≤r is the number ofdominant matches (elsewhere referred to asminimal candidates) between the two strings. Both algorithms require anO(n logs) preprocessing that is nearly standard for the LCS problem, and they make use of simple and handy auxiliary data structures.

Improving the worst-case performance of the Hunt-Szymanski strategy for the longest common subsequence of two strings

Among the algorithms set up to date for finding the longest common subsequence of two strings, the one by Hunt and Szymanski exhibits the best known performance in favorable cases, but can be worse than any straightforward algorithm for a large variety of inputs. The new algorithm presented here pursues a schedule of primitive operations quite close to the one inherent to the Hunt-Szymanski strategy, but with substantially enhanced efficiency. In fact, the new algorithm improves on the former in two important respects. First, its worst case is never worse than linear in the product nm of the lengths of the two input strings. Second, its time bound does not always grow with the cardinality r of the set R of all pairs of matching positions of the input strings. Rather, it depends on the cardinality d of a specific subset of R, whose elements are called here dominant matches, and are elsewhere referred to as minimal candidates. This second improvement also appears of significance, since it seems that whenever r gets too close to mn, this forces d to be linear in m. The new algorithm requires standard preprocessing, and makes use of finger-trees. In a forthcoming paper, it will be shown among other things that the same performance can be achieved with simpler and handier auxiliary data structures.

ARTS: Accelerated Ray-Tracing System

In this article we propose algorithms that address the two basic problems encountered in generating continuous-tone images by ray tracing: speed and aliasing. We examine previous approaches to the problem and then propose a scheme based on the coherency of an auxiliary data structure imposed on the original object domain. After investigating both simple spatial enumeration and a hybrid octree approach, we developed 3DDDA, a 3D line generator for efficient traversing of both structures. 3DDDA provides an order of magnitude improvement in processing speed compared to other known ray-tracing methods. Processing time is found to be virtually independent of the number of objects involved in the scene. For large numbers of objects, this method actully becomes faster than scan-line methods. To remove jags from edges, a scheme for identifying edge orientation and distance from pixel center to true edge has been implemented. The time required for antialiasing depends on the total length of the edges encountered, but it is normally only a fractional addition to the time needed to produce the scene without antialiasing.

Large Software Problems for Small Computers: An Example from Medical Imaging

Small computers can be called on to perform large tasks. Doing so requires careful organization of input, output, auxiliary data structures, and memory.

Monte Carlo study of weighted percolation clusters relevant to the Potts models

The two-dimensional Potts models were simulated with the use of a Monte Carlo method. This study is unique in that we simulated the weighted percolation clusters first described by Kasteleyn and Fortuin in 1969. We describe an auxiliary data structure which enables us to determine the connectedness of large clusters very efficiently. Our simulation of the percolation problem was found not to be affected by a critical slowing down. Critical exponents were found by studying the size and shape of large clusters. Our results agree with previous studies done on integer values of $q$, and with the conjecture of den Nijs.

The Theory and Practice of Constructing an Optimal Polyphase Sort

The construction of both an optimal read-forward polyphase sort and a near optimal read-backward version is described. The former minimizes the merge volume, for a given distribution of strings, without the use of auxiliary data structures, and incorporates a new technique for computing the positions of dummy strings. In the case of the readbackward version, an approach is developed which achieves a merge volume nearest to the minimum, inasmuch as the theoretical optimal read-backward polyphase sort cannot be realized. A dispersion algorithm is also described which optimizes the distribution of strings so that minimum merge volume is assured.