23
November Meeting 15, 2004
Searching with Strings
This material is not covered in our textbook but you can read about keyword trees and sufx trees in Chapters I and II of Algorithms on Strings, Trees, and Sequences by G USFIELD.
o
1
p
1
t a
2 3 1 1 2
t h e r
1 1
o t t t
o t h e r 1
p o t a t o 2
t a t t o o 3 r 4 h e a t e
3
2
1 1
2
a t o
o o
3
Figure 109: The keyword tree of Figure 108 with failure links speeding up the search. The number next to each link is the depth of the target node. The links back to the root are not shown.
84
E
f
edge is labeled with a character, and the paths from the root to the leaves spell out the patterns. We refer to this
convenience, we let point to the root if . The search algorithm maintains a current node , which it initializes to the root, , of the tree. It also uses two pointers into the text array: precedes the starting position
7 e & 5 72 )dA@P
!
7 cWbSQ VT R
Figure 108: The keyword tree for the patterns other, potato, tattoo, theater.
Y
5 72 A4P
7
7
7 XWUSQ VT R 5 72 A! @B8
5 Y2 a`98
String Matching with a Collection of Patterns. We generalize string matching to a collection of patterns . For each pattern, we ask whether or not it occurs as a substring of a given text . It is convenient to assume that the collection is prex-free, that is, no pattern is a prex of any other pattern, although this is not necessary but leads to complications we would like to avoid. With the length of pattern , we let be the total length of the patterns. Assuming the alphabet has constant size, , we can store the patterns in a tree in which every node has degree at most . Each
Failure Function for Keyword Trees. We improve the running time by adapting the idea of a failure function to keyword trees. For each node , let be the length of the longest sufx of that is a prex of some pattern. We store a link from to the node for which is this prex. This is illustrated in Figure 109. For
h e a
1
t e r
4
5 72 A@98 ! " H
F GE
5 72 A@B8 7
5 2 I# 31
7
5A@2DC 7 7
5 #2 6431
We consider three generalizations of the string matching problem: searching with a collection of patterns instead of just one, allowing wild-cards in the pattern, and searching for common substrings. We present two data structures: the keyword tree, which solves the rst two generalizations, and the sufx tree, which solves the rst generalization and the third.
as the keyword tree of the patterns, assuming the outgoing edges of a node are sorted according to an ordering of the alphabet, as in Figure 108. It is easy to construct the tree in time . Each node corresponds to a prex of a pattern. If is a leaf, is an entire pattern and we store its index at . To search with the text, we traverse a longest common prex for each sufx , which takes time .
0
$
! "
0
$ %#
$ %# $ )'# ( &
85
&
In our example, 13, and 20, and
ABRA increments for indices 10, A increments at indices 0, 3, 6,
P
&
Step 2. Scan .
"&
and report every position
with
String Matching with Sufx Trees. Given the sufx tree for text , we can determine whether or not the pat-
5 31 2
Step 1. For each , nd all starting positions of in and increment by one, provided .
It is straightforward to construct the sufx tree in time , simply by adding the sufxes one at a time. It is more difcult but possible to construct it in time . One strategy is to read the text from front to back, and for each new character to expand all sufxed by one and start one new sufx. The details are complicated and omitted.
)F
5
2 31
#
Sting Matching with Wild-cards. We can use keyword trees to solve the string matching problem in which we allow for wild-cards, *, in the pattern. The wild-card is a special character that matches any (single) character in the text. For example, the pattern ABRA******A occurs twice in HOCUSPOCUSABRABRACADABRA, starting after positions 10 and 13. Instead of concurrently following different branches for each wild-card, we search for each maximal substring without wild-cards, and we record each match at the text position preceding the rst (full) pattern position. We use an integer array to record the matches. Initially, is all zero. Let be the maximal substrings of the pattern that do not contain any wild-cards. For each , we let be the position preceding in the pattern. For example, for ABRA******A we have ABRA with and A with . We store the in a keyword tree with added failure links.
i
pp
7
10
0
i$
mi
i
ss
i$
s is
ip
p
pi
$
$
s
11
$
$
ppi
ppi
ppi
$
9
8
4
1
6
3
5
2
Figure 110: The sufx tree of the text mississippi.
ternal node has two or more children, the size of the tree is linear in the length of the text. Indeed, there are leaves and therefore at most internal nodes and at most edges. An edge-label can be an arbitrarily long string, but we can store it using only two integers giving the rst and last positions in the text. We also note that any two edges connecting a node with its children are labeled by strings that begin with different characters.
'
It is convenient to assume stores a special endsymbol that avoids patterns are compared with entries beyond the end of the text array. We omit the construction of and the failure links , which takes the lengths time . The running time of the search algorithm is because every step either advances the position in the text and simultaneously increases the depth of the node in the tree, or it reduces the depth, which cannot be done more often than increasing the depth.
! "
1 0 0 ) & ( F E '
c c e !
&
F T & T T F E & $ ! T !
; ; repeat while has child with edge-label if is leaf then print else ; endif endwhile; ; .
do
Sufx until Trees. The string matching algorithms we have discussed so far preprocess the pattern, which is the smaller of the two strings, and use the obtained structure to nd matches in time proportional to the length of the text. We now turn things around and preprocess the text. Specically, we take the collection of sufxes, , and construct the keyword tree for . To avoid complications, we enforce the prex-free property by appending the special character $ to each . We thus get a bijection between the leaves of the tree and the sufxes of the text. In each leaf, we record the position preceding the starting position of the corresponding sufx. Finally, we remove each non-branching internal node, merging its two edges into one and concatenating their labels. We thus obtain the sufx tree of , illustrated in Figure 110. We note that because every in-
5 # 6GF 31 2 & % & % & ! $# ! $#
pi $
T
of the substring currently matched with the pattern, and is the position currently tested.
8, 10, and 13. There are therefore two occurrences of the pattern in the text, the rst at ABRABRACADA and the second at ABRACADABRA. The total running time is .
e &
!
$
E
!
$
7 XWUSQ VT R
$
!
F
$
!
&
C G
Y & 7
7 cWbSQ I7 A@P VT R & 5 72
Y
f )& 7 & T e BE & e & $ a!E $ $ 5 72 A@P
E
7
5 I# F 31 2 5 #2 I@31
T
SE F
Y
!
P
& BE
$ i$ ipp ssi ss
si
ssi ppi $
ssi ppi $
&
86
5 0)F @31 ' %# #2
Step 2. Mark internal nodes and determine their string-depths.
Step 1. Construct the sufx tree for
and
.
The sufx array stores 12 integers, one more than the length of the text, which for mississippi are 11, 10, 7, 4, 1, 0, 9, 8, 6, 3, 5, 2. We can construct the sufx array from the sufx tree by in-order traversal, but for that we have to interpret $ lexicographically smaller than all other characters in the alphabet. A key property of the array is that it groups sufxes with common prexes together in contiguous positions. We can therefore use binary search to nd all sufxes that contain a given pattern . This takes time , which is not quite as fast as the sufx tree itself, but the array takes less memory. Also, there are methods that can speed up the search to time , which as fast as the sufx tree unless the size of the text exceeds 2 to the size of the pattern.
&
5 (&$@31 ' %# #2
"
#
!
Longest Common Substrings. A classic problem in string analysis is to nd the longest substring common to two given strings, and . For example, if austrialife and australialife then the longest common substring is ialife. To nd it, we construct the sufx tree for both texts, representing the sufxes of and of , each by a path from the root to a leaf. Each leaf represents a sufx of one string or of both. We mark each internal node with 1 if at least one of the leaves in its subtree represents a sufx of . Similarly, we mark with 2 if at least one of the leaves in its subtree represents a sufx of . If an internal node has both marks, then its path spells out the prex of a sufx as well as a sufx of . In other words, it spells of out a substring of both. Call the length of this substring the string-depth of . To nd the longest common substring, we just need to nd the internal node with maximum string-depth that has both marks. We summarize the algorithm:
e
e
%
&
Using the linear-time a...