suffix trees

Suffix TreesConstruction and Applications

João Carreira

2008

Outline

Why Suffix Trees? Definition Ukkonen's Algorithm (construction)

Applications

Why Suffix Trees?

Why Suffix Trees?

Asymptotically fast.

Why Suffix Trees?

Asymptotically fast. The basis of state of the art data structures.

Why Suffix Trees?

Asymptotically fast. The basis of state of the art data structures. You don't need a Phd to use them.

Why Suffix Trees?

Asymptotically fast. The basis of state of the art data structures. You don't need a Phd to use them. Challenging.

Why Suffix Trees?

Asymptotically fast. The basis of state of the art data structures. You don't need a Phd to use them. Challenging. Expose interesting algorithmic ideas.

Definition

m leaves numbered 1 to m

Suffix Tree for an m-character string:

Definition

m leaves numbered 1 to m edge-label vs node-label

Suffix Tree for an m-character string:

Definition

m leaves numbered 1 to m edge-label vs node-label each internal node has at least two children

Suffix Tree for an m-character string:

Definition

m leaves numbered 1 to m edge-label vs node-label each internal node has at least two children the label of the leaf j is S[ j..m ]

Suffix Tree for an m-character string:

Definition

m leaves numbered 1 to m edge-label vs node-label each internal node has at least two children the label of the leaf j is S[ j..m ] no two edges out of the same node can have edge-labels

beginning with the same character

Suffix Tree for an m-character string:

Definition Example

String: xabxac

Length (m): 6 characters

Number of Leaves: 6

Node 5 label: ac

Implicit vs Explicit What if we have “axabx” ?

Ukkonen's Algorithmsuffix tree construction

Ukkonen's Algorithm

Text: S[ 1..m ] m phases phase j is divided into j extensions:

In extension j of phase i + 1: find the end of the path from the root labeled with substring S[ j..i ] extend the substring by adding the character S(i + 1) to its end

suffix tree construction

Extension Rules Rule 1: Path β ends at a leaf. S(i + 1) is added to the end of the label on that leaf edge.

Extension Rules Rule 2: No path from the end of β starts with S(i + 1), but at least one labeled path

continues from the end of β.

Extension Rules Rule 3: Some path from the end of β starts with S(i + 1), so we do nothing.

Ukkonen's Algorithm

Complexity:

suffix tree construction

Ukkonen's Algorithm

Complexity:

m phases

suffix tree construction

Ukkonen's Algorithm

Complexity:

m phases phase j -> j extensions

suffix tree construction

Ukkonen's Algorithm

Complexity:

m phases phase j -> j extensions find the end of the path of substring β: O(|β|) = O(m)

suffix tree construction

Ukkonen's Algorithm

Complexity:

m phases phase j -> j extensions find the end of the path of substring β: O(|β|) = O(m) each extension: O(1)

suffix tree construction

Ukkonen's Algorithm

Complexity:

m phases phase j -> j extensions find the end of the path of substring β: O(|β|) = O(m) each extension: O(1)

O(m3)

suffix tree construction

“First make it run, then make it run fast.”

Brian Kernighan

Suffix LinksDefinition:

For an internal node v with path-label xα, if there is another node s(v), with

path-label α, then a pointer from v to s(v) is called a suffix link.

Suffix LinksLemma:

If a new internal node v with path label xα is added to the current tree in extension

j of some phase, then either the path labeled α already ends at an internal node

or an internal at the end of the string α will be created in the next extension

of the same phase.

If Rule 2 applies:

Suffix LinksLemma:

If a new internal node v with path label xα is added to the current tree in extension

j of some phase, then either the path labeled α already ends at an internal node

or an internal at the end of the string α will be created in the next extension

of the same phase.

If Rule 2 applies:

S[ j..i ] continues with c ≠ S(i + 1)

Suffix LinksLemma:

If a new internal node v with path label xα is added to the current tree in extension

j of some phase, then either the path labeled α already ends at an internal node

or an internal at the end of the string α will be created in the next extension

of the same phase.

If Rule 2 applies:

S[ j..i ] continues with c ≠ S(i + 1) S[ j + 1..i ] continues with c.

Single Extension Algorithm

Extension j of phase i + 1:

1. Find the first node v at or above the end of S[ j - 1..i ] that either has a suffix link

from it or is the root. Let λ denote the string between v and the end of S[ j – 1..i ].

Single Extension Algorithm

Extension j of phase i + 1:

1. Find the first node v at or above the end of S[ j - 1..i ] that either has a suffix link

from it or is the root. Let λ denote the string between v and the end of S[ j – 1..i ].

2. If v is the root, follow the path for S[ j..i ] (as in the naive algorithm). Else traverse the

suffix link and walk down from s(v) following the path for string λ.

Single Extension Algorithm

Extension j of phase i + 1:

1. Find the first node v at or above the end of S[ j - 1..i ] that either has a suffix link

from it or is the root. Let λ denote the string between v and the end of S[ j – 1..i ].

2. If v is the root, follow the path for S[ j..i ] (as in the naive algorithm). Else traverse the

suffix link and walk down from s(v) following the path for string λ.

3. Using the extension rules, ensure that the string S[ j..i ] S(i+1) is in the tree.

Single Extension Algorithm

Extension j of phase i + 1:

1. Find the first node v at or above the end of S[ j - 1..i ] that either has a suffix link

from it or is the root. Let λ denote the string between v and the end of S[ j – 1..i ].

2. If v is the root, follow the path for S[ j..i ] (as in the naive algorithm). Else traverse the

suffix link and walk down from s(v) following the path for string λ.

3. Using the extension rules, ensure that the string S[ j..i ] S(i+1) is in the tree.

4. If a new internal w was created in extension j – 1 (by rule 2), then string α must

end at node s(w), the end node for the suffix link from w. Create the suffix link

(w, s(w)) from w to s(w).

Node Depth

The node-depth of v is at most one greater than the node depth of s(v).

α

ßxß

xα

xλ λ

xß

xα

xλ

ß

α

λ

equal node-depth: 3Node depth: 4 Node depth: 3

γ number of characters in an edge “Directly implemented” edge traversal: O(|γ|)

Skip/count Trick

Skip/count Trick

“Jump” from node to node. K = number of nodes in a path Time to traverse a path: O(|K|)

γ number of characters in an edge “Directly implemented” edge traversal: O(|γ|)

Ukkonen's AlgorithmUsing the skip/count trick: any phase of Ukkonen's algorithm takes O(m) time.

Proof:

Ukkonen's AlgorithmUsing the skip/count trick: any phase of Ukkonen's algorithm takes O(m) time.

Proof:

There are i + 1 ≤ m extensions in phase i + 1

Ukkonen's AlgorithmUsing the skip/count trick: any phase of Ukkonen's algorithm takes O(m) time.

Proof:

There are i + 1 ≤ m extensions in phase i + 1 In a single extension, the algorithm walks up at most one edge, traverses one suffix link,

walks down some number of nodes, applies the extension rules and may add a suffix link.

Ukkonen's AlgorithmUsing the skip/count trick: any phase of Ukkonen's algorithm takes O(m) time.

Proof:

There are i + 1 ≤ m extensions in phase i + 1 In a single extension, the algorithm walks up at most one edge, traverses one suffix link,

walks down some number of nodes, applies the extension rules and may add a suffix link. The up-walk decreases the current node-depth by at most one.

Ukkonen's AlgorithmUsing the skip/count trick: any phase of Ukkonen's algorithm takes O(m) time.

Proof:

There are i + 1 ≤ m extensions in phase i + 1 In a single extension, the algorithm walks up at most one edge, traverses one suffix link,

walks down some number of nodes, applies the extension rules and may add a suffix link. The up-walk decreases the current node-depth by at most one. Each suffix link traversal decreases the node-depth by at most another one.

Ukkonen's AlgorithmUsing the skip/count trick: any phase of Ukkonen's algorithm takes O(m) time.

Proof:

There are i + 1 ≤ m extensions in phase i + 1 In a single extension, the algorithm walks up at most one edge, traverses one suffix link,

walks down some number of nodes, applies the extension rules and may add a suffix link. The up-walk decreases the current node-depth by at most one. Each suffix link traversal decreases the node-depth by at most another one. Each down-walk moves to a node of greater depth.

Ukkonen's AlgorithmUsing the skip/count trick: any phase of Ukkonen's algorithm takes O(m) time.

Proof:

There are i + 1 ≤ m extensions in phase i + 1 In a single extension, the algorithm walks up at most one edge, traverses one suffix link,

walks down some number of nodes, applies the extension rules and may add a suffix link. The up-walk decreases the current node-depth by at most one. Each suffix link traversal decreases the node-depth by at most another one. Each down-walk moves to a node of greater depth. Over the entire phase the node-depth is decremented at most 2m times.

Ukkonen's AlgorithmUsing the skip/count trick: any phase of Ukkonen's algorithm takes O(m) time.

Proof:

There are i + 1 ≤ m extensions in phase i + 1 In a single extension, the algorithm walks up at most one edge, traverses one suffix link,

walks down some number of nodes, applies the extension rules and may add a suffix link. The up-walk decreases the current node-depth by at most one. Each suffix link traversal decreases the node-depth by at most another one. Each down-walk moves to a node of greater depth. Over the entire phase the node-depth is decremented at most 2m times. No node can have depth greater than m, so the total increment to current node-depth

(down walks) is bounded by 3m over the entire phase.

Ukkonen's Algorithm

m phases 1 phase: O(m)

Ukkonen's Algorithm

m phases 1 phase: O(m)

O(m2)

“First make it run fast, then make it run faster.”

João Carreira

Edge-Label Compression

A string with m characters has m suffixes.

If edge labels are represented with characters, O(m2) space is needed.

Edge-Label Compression

A string with m characters has m suffixes.

If edge labels are represented with characters, O(m2) space is needed.

To achieve O(m) space, each edge-label:

(p, q)

Two more tricks...

Rule 3 is a show stopper

If rule 3 applies in extension j, it will also apply in all further

extensions until the end of the phase.

Why?

Rule 3 is a show stopper

If rule 3 applies in extension j, it will also apply in all further

extensions until the end of the phase.

Why?

When rule 3 applies, the path labeled S[ j..i ] must continue with character S(i + 1), and

so the path labeled S[ j + 1..i ] does also, and rule 3 again applies in extensions j+1...i+1.

Rule 3 is a show stopper

End any phase i +1 the first time rule 3 applies.

The remaining extensions are said to be done implicitly.

Once a leaf always a leaf

Leaf created => always a leaf in all successive trees. No mechanism for extending a leaf edge beyond its current leaf.

Once there is a leaf labeled j, extension rule 1 will always apply to extension j

in any sucessive phase.

Once a leaf always a leaf

Leaf created => always a leaf in all successive trees. No mechanism for extending a leaf edge beyond its current leaf.

Once there is a leaf labeled j, extension rule 1 will always apply to extension j

in any sucessive phase.

Leaf Edge Label: (p, e)

Single Phase Algorithm

In each phase i:

Single Phase Algorithm

During construction:

Implicit to Explicit

One last phase to add character $: O(m)

Suffix Trees are a Swiss Knife

ApplicationsExact String Matching:

ApplicationsExact String Matching:

Three ocurrences of string aw.

Preprocessing: O(m)

Search: O(n + k)

ApplicationsAnd much more..

Longest common substring

O(n) Longest repeated substring

O(n) Longest palindrome

O(n) Most frequently occurring substrings of a minimum length

O(n) Shortest substrings occurring only once

O(n) Lempel-Ziv decomposition

O(n) .....

“Biology easily has 500 years of exciting problems to work on.”

Donald Knuth

web.ist.utl.pt/joao.carreira

Questions?