The.Algorithm.Design.Manual.Springer-Verlag.1998

War Story: String 'em Up
We were convinced that using several small arrays would be more efficient than using one big array. We
even had theory to justify our technique, but biologists aren't very inclined to believe theory. They
demand experiments for proof. Hence we had to implement our algorithms and use simulation to prove
that they worked.
So much for motivation. The rest of this tale will demonstrate the impact that clever data structures can
have on a string processing application.
Our technique involved identifying all the strings of length 2k that are possible substrings of an unknown
string S, given that we know all length k substrings of S. For example, suppose we know that AC, CA,
and CC are the only length-2 substrings of S. It is certainly possible that ACCA is a substring of S, since
the center substring is one of our possibilities. However, CAAC cannot be a substring of S, since we
know that AA is not a substring of S. We needed to find a fast algorithm to construct all the consistent
length-2k strings, since S could be very long.
Figure: The concatentation of two fragments can be in S only if all subfragments are
The simplest algorithm to build the 2k strings would be to concatenate all pairs of k-strings
together, and then for each pair to make sure that all (k-1) length-k substrings spanning the boundary of
the concatenation were in fact substrings, as shown in Figure . For example, the nine possible
concatenations of AC, CA, and CC are ACAC, ACCA, ACCC, CAAC, CACA, CACC, CCAC, CCCA, and
CCCC. Only CAAC can be eliminated because of the absence of AA.
We needed a fast way of testing whether each of the k-1 substrings straddling the concatenation was a
member of our dictionary of permissible k-strings. The time it takes to do this depends upon which kind
of data structure we use to maintain this dictionary. With a binary search tree, we could find the correct
string within comparisons, where each comparison involved testing which of two length-k strings
appeared first in alphabetical order. Since each such comparison could require testing k pairs of
characters, the total time using a binary search tree would be .
That seemed pretty good. So my graduate student Dimitris Margaritis implemented a binary search tree
data structure for our implementation. It worked great up until the moment we ran it.
file:///E|/BOOK/BOOK/NODE39.HTM (2 of 5) [19/1/2003 1:28:38]