Ukkonen's suffix tree construction algorithm

Transcription

1 Ukkonen's suffix tree construction algorithm aba$ $ab aba$ $ab a ba $ 3 $ $ab a ba $ $ $ String Algorithms; Nov

2 Motivation Yet another suffix tree construction algorithm... Why?

3 Motivation Yet another suffix tree construction algorithm... Why? An online algorithm, i.e. one we can update with new sequences

4 Sketch of algorithm Recall McCreight s approach: For i = 1.. n+1, build compressed trie of {x[..n]$ i} Ukkonen s approach: For i = 1.. n+1, build compressed trie of {$ i} Compressed trie of all suffixes of prefix x[1..i]$ of x$ A suffix tree except for leaf property

5 McCreight's algorithm x=aba T 1 : {x$[..n] 1 } aba$ 1 T 2 : {x$[..n] 2 } T 3 : {x$[..n] 3 } $a b 2 2 $ab aba$ a ba $ 3 1 $ 1 T 4 : {x$[..n] 4 } 2 $ab a ba $ $ 4 $ 3 1

6 Ukkonen's algorithm x=aba T 1 : {x$[..1]} a 1 T 2 : {x$[..2]} b ab 2 1 T 3 : {x$[..3]} 2 aba ba 1 Note: no node for x[3..3] = a T 4 : {x$[..n]} 2 $ab $ 4 a ba$ $ 1 3

7 Tasks in iteration i In iteration i we must Update each to x[..i+1] Add string (special case of above) Leaf: Inner node: Edge:

8 First attempt... Obvious algorithm: For i=1,...,n+1: for =1,...,i: find append Running time O(n 3 ) Need lots of tricks to get O(n)!

9 Updating leaves for free If we label leaves with (k, ) denoting k to the current i, updating a leaf is automatic Leaf: Inner node: Edge:

10 Updating existing strings is free If x[..i+1] is already in the tree, the update is automatic Leaf: Inner node: Edge:

11 Real operations If we can recognize the free operations, we need only deal with the remaining Leaf: Inner node: Edge:

12 Lemma Let denote suffix of x[1..i] a)if >1 is a leaf node in T i, then so is -1 b)if, from <i, there is a path in T i that begins with a, then there is a path in T i from +1 beginning with a

13 Lemma Let denote suffix of x[1..i] a)if >1 is a leaf node in T i, then so is -1 b)if, Once from an <i, edge, there always is a path an in edge T i that begins with a, then there is a path in T i from +1 beginning with a

14 Lemma Let denote suffix of x[1..i] a)if Once >1 is a leaf, node always in been T i, then a leaf so is -1 b)if, from <i, there is a path in T i that begins with a, then there is a path in T i from +1 beginning with a

15 Proof of lemma a) If >1 is a leaf node in T i, then so is -1 Assume -1 is not a leaf. Then there exists k<-1 such that: x[k..i] x[-1..i] x[k..i] x[-1..i] -1 k Then -1 k k+1 thus: x[k+1..i] x[k+1..i]

16 Proof of lemma b) If, from <i, there is a path in T i that begins with a, then there is a path in T i from +1 beginning with a Assume is followed by a, then there exists k< such that: k a thus: +1 k+1 a Hence +1 is followed by a.

17 Corollary In iteration i, there exist indices L and R such that: All suffixes L are leaves All suffixes R are already in the trie I II III L R

18 Consequence of corollary I and III are free operations I II III L R

19 Updated algorithm Implicitly handling free operations: For i=1,...,n+1: for = L,..., R : find append L in iteration i is the last leaf inserted in iteration i-1 (all smaller indices are already leaves) R in iteration i is the first index where x[..i+1] is already in the trie (all larger indices are already in the trie)

20 Suffixes in II are made into leaves Whenever L < < R, is made a leaf:

21 Suffixes in II are made into leaves Whenever L < < R, is made a leaf: Once is a leaf, it will be in I and never in II again

22 Time to go from II to I We handle in II or implicitly in III time 2n: 2 2 Index in II n+1 Path length is 2n Iterations n+1

23 Updated running time Only 2n of these: For i=1,...,n+1: for = L,..., R : find append Constant time Running time is 2n*T(find )

24 Updated running time Only 2n of these: For i=1,...,n+1: for = L,..., R : find append Constant time? Constant time Running time is 2n*T(find ) We ust have to deal with T(find ) in O(1) No worries!

25 Using fastscan and s(-) When searching for, it is already in the trie We can use fastscan for the search T(find ) in O(d) where d is the (node-)depth of If we keep suffix links, s(-), in the tree we can use these as shortcuts

26 Suffix links Invariant: All inner nodes have suffix links

27 Suffix links Invariant: All inner nodes have suffix links Ensuring the invariant: We only insert inner nodes when adding leaves Whenever we insert a new node, for some <i, we also find or insert x[+1..i], and can update s() := x[+1..i] If we insert x[i..i], then s(x[i..i]) :=

28 Finding x[+1..i] from parent() s s(parent()) x[+1..i] Starting from here (initial is L and we can keep a pointer to that node between iterations) Using fastscan here

29 Bound on fastscan Time usage by fastscan is bounded by n for the maximal (node-)depth in the trie plus total decrease of (node-)depth Decrease in depth: Moving to parent(): 1 Moving to s(parent()): max 1 Restarting at L :?

30 Bound on fastscan Time usage by fastscan is bounded by n for the maximal (node-)depth in the trie plus total decrease of (node-)depth Decrease in depth: Moving to parent(): 1 Moving to s(parent()): max 1 Restarting at L :? parent() s s(parent()) x[+1..i] Using fastscan here

31 Hacking the suffix link When searching for x[ L +1..i], update s(x[ L..i]) to point to the nearest ancestor of x[ L +1..i] parent( L ) s s(parent( L )) L x[ L +1..i] Nearest ancestor of x[ L +1..i]

32 Hacking the suffix link When searching for x[ L +1..i], update s(x[ L..i]) to point to the nearest ancestor of x[ L +1..i] parent( L ) s s(parent( L )) L x[ L +1..i] Restart in constant time Nearest ancestor of x[ L +1..i]

33 Iterations Searching time Vertical steps are paid for by the previous horizontal step (free restarting) Horizontal steps are total fastscan bounded by O(n) Runtime O(n) Index in II 2 2 n+1 n+1

34 Summary We have seen a new suffix tree construction algorithm Ukkonen s algorithm is an online algorithm: As long as no suffix is a prefix of another, the intermediate trees are suffix trees Generalized suffix trees can be built one string at a time