Ukkonen s suffix tree algorithm

Transcription

1 Ukkonen s suffix tree 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 Nov String algorithms, Q

2 McCreight s algorithm, x=aba T 1 : {x$[..n] 1 } aba$ T 2 : {x$[..n] 2 } T 3 : {x$[..n] 3 } 2 $ab 2 $ab 1 aba$ 1 a ba$ $ 1 3 T 4 : {x$[..n] 4 } 2 $ab $ 4 a ba$ $ 3 1 Nov String algorithms, Q

3 Ukkonen s algorithm, x=aba T 1 : {x$[..1]} a 1 T 2 : {x$[..2]} b ab 2 1 T 3 : {x$[..3]} ab a ba Note: no node for x[3..3] = a 2 1 T 4 : {x$[..n]} 2 $ab $ 4 a ba$ $ 3 1 Nov String algorithms, Q

4 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: Nov String algorithms, Q

5 Simple algorithm 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)! Nov String algorithms, Q

6 Free operations leaves If we label leaves with (k, ) denoting k to the current i, updating a leaf is automatic Leaf: Inner node: Edge: Nov String algorithms, Q

7 Free operations existing strings If x[..i+1] is already in the tree, the update is automatic Leaf: Inner node: Edge: Nov String algorithms, Q

8 Real operations If we can recognize the free operations, we need only deal with the remaining Leaf: Inner node: Edge: Nov String algorithms, Q

9 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 Nov String algorithms, Q

10 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 thus: x[k+1..i] x[k+1..i] k k+1 Nov String algorithms, Q

11 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 there exists k< such that: k a thus: +1 k+1 a Hence +1 is followed by a. Nov String algorithms, Q

12 Corollary of lemma 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 Nov String algorithms, Q

13 Corollary of lemma I and III are free operations I II III L R Nov String algorithms, Q

14 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 ( once a leaf, always a leaf ) R in iteration i is the first index where x[..i+1] is already in the trie Nov String algorithms, Q

15 Handling index in II Whenever L < < R, is made a leaf: Once is a leaf, it will be in I and never in II again Nov String algorithms, Q

16 Handling index in II We handle in II or implicitly in III 2n times: Index in II 2 2 n+1 Path length is 2n Iterations n+1 Nov String algorithms, Q

17 Runtime Only 2n of these: For i=1,...,n+1: for = L,..., R : find append Constant time Running time is 2n*T(find ) We ust have to deal with T(find ) in O(1) No worries! Nov String algorithms, Q

18 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 Nov String algorithms, Q

19 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]) := Nov String algorithms, Q

20 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 Nov String algorithms, Q

21 Bound on fastscan Time usage by fastscan is bounded by n for the maximal (node-)depth in the trie + total decrease of (node-)depth Decrease in depth: Moving to parent(): 1 Moving to s(parent()): max 1 Restarting at L :? Nov String algorithms, Q

22 Hacking the suffix links 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] Restarting becomes essentially free Nov String algorithms, Q

23 Running 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) 2 2 Index in II n+1 Iterations n+1 Nov String algorithms, Q

24 Why Ukkonen? 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 Nov String algorithms, Q