dynamic trees n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Dynamic Trees PowerPoint Presentation
Download Presentation
Dynamic Trees

Loading in 2 Seconds...

play fullscreen
1 / 96

Dynamic Trees - PowerPoint PPT Presentation


  • 143 Views
  • Uploaded on

Dynamic Trees. Goal: maintain a forest of rooted trees with costs on vertices. Each tree has a root, every edge directed towards the root. Operations allowed: link( v , w ) : creates an edge between v (a root) and w . cut( v , w ) : deletes edge ( v , w ).

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Dynamic Trees' - elysia


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
dynamic trees
Dynamic Trees
  • Goal: maintain a forest of rooted trees with costs on vertices.
    • Each tree has a root, every edge directed towards the root.
  • Operations allowed:
    • link(v,w): creates an edge between v (a root) and w.
    • cut(v,w): deletes edge (v,w).
    • findcost(v): returns the cost of vertex v.
    • findroot(v): returns the root of the tree containing v.
    • findmin(v): returns the vertex w of minimum cost on the path from v to the root (if there is a tie, choose the closest to the root).
    • addcost(v,x): adds x to the cost every vertex from v to root.

Dynamic Trees

dynamic trees1
Dynamic Trees
  • An example (two trees):

a

3

b

c

6

2

1

d

j

1

7

e

4

f

g

3

h

9

i

4

l

8

6

k

7

2

m

n

o

4

p

6

q

1

s

2

r

8

t

6

u

4

Dynamic Trees

dynamic trees2
Dynamic Trees

a

a

3

3

b

c

6

2

b

c

6

2

1

d

1

d

j

j

1

7

link(q,e)

1

7

e

4

e

4

f

g

3

h

9

i

4

f

g

3

h

9

i

4

l

8

6

q

l

8

6

k

7

2

1

k

7

2

m

n

m

n

s

2

r

8

o

4

p

6

o

4

p

6

q

1

t

6

u

4

s

2

r

8

t

6

u

4

Dynamic Trees

dynamic trees3
Dynamic Trees

a

a

3

3

b

c

6

2

b

c

6

2

1

d

1

d

j

j

1

7

cut(q)

1

7

e

4

e

4

f

g

3

h

9

i

4

f

g

3

h

9

i

4

l

8

6

q

l

8

6

k

7

2

1

k

7

2

m

n

m

n

s

2

r

8

o

4

p

6

o

4

p

6

q

1

t

6

u

4

s

2

r

8

t

6

u

4

Dynamic Trees

dynamic trees4
Dynamic Trees
  • findmin(s) = b
  • findroot(s) = a
  • findcost(s) = 2
  • addcost(s,3)

a

3

b

c

6

2

1

d

j

1

7

e

4

f

g

3

h

9

i

4

q

l

8

6

1

k

7

2

m

n

s

2

r

8

o

4

p

6

t

6

u

4

a

6

b

c

6

2

4

d

j

1

7

e

7

f

g

3

h

9

i

4

q

l

8

6

4

k

7

2

m

n

s

5

r

8

o

4

p

6

t

6

u

4

Dynamic Trees

obvious implementation
Obvious Implementation
  • A node represents each vertex;
  • Each node x points to its parent p(x):
    • cut, split, findcost: constant time.
    • findroot, findmin, addcost: linear time on the size of the path.
  • Acceptable if paths are small, but O(n) in the worst case.
  • Cleverer data structures achieve O(log n) for all operations.

Dynamic Trees

simple paths
Simple Paths
  • We start with a simpler problem:
    • Maintain set of paths subject to:
      • split: cuts a path in two;
      • concatenate: links endpoints of two paths, creating a new path.
    • Operations allowed:
      • findcost(v): returns the cost of vertex v;
      • addcost(v,x): adds x to the cost of vertices in path containing v;
      • findmin(v): returns minimum-cost vertex path containing v.

v1

v2

v3

v4

v5

v6

v7

Dynamic Trees

simple paths as lists
Simple Paths as Lists
  • Natural representation: doubly linked list.
    • Constant time for findcost.
    • Constant time for concatenate and split if endpoints given, linear time otherwise.
    • Linear time for findminand addcost.
  • Can we do it O(log n) time?

costs:

6

2

3

4

7

9

3

v1

v2

v3

v4

v5

v6

v7

Dynamic Trees

simple paths as binary trees
Simple Paths as Binary Trees
  • Alternative representation: balanced binary trees.
    • Leaves: vertices in symmetric order.
    • Internal nodes: subpaths between extreme descendants.

(v1,v7)

(v4,v7)

(v1,v3)

(v4,v6)

(v1,v2)

(v5,v6)

v1

v2

v3

v4

v5

v6

v7

Dynamic Trees

simple paths as binary trees1
Simple Paths as Binary Trees
  • Compact alternative:
    • Each internal node represents both a vertex and a subpath:
      • subpath from leftmost to rightmost descendant.

v6

v2

v7

v1

v4

v3

v5

v1

v2

v3

v4

v5

v6

v7

Dynamic Trees

simple paths maintaining costs
Simple Paths: Maintaining Costs
  • Keeping costs:
    • First idea: store cost(x) directly on each vertex;
    • Problem: addcost takes linear time (must update all vertices).

actual costs

9

v6

2

v2

3

v7

6

v1

4

v4

3

v3

7

v5

costs:

6

2

3

4

7

9

3

v1

v2

v3

v4

v5

v6

v7

Dynamic Trees

simple paths maintaining costs1
Simple Paths: Maintaining Costs
  • Better approach: store cost(x) instead:
    • Root: cost(x) = cost(x)
    • Other nodes: cost(x) = cost(x) –cost(p(x))

actual costs

9

v6

difference form

9

v6

2

v2

3

v7

-7

v2

-6

v7

6

v1

4

v4

4

v1

2

v4

3

v3

7

v5

-1

v3

3

v5

costs:

6

2

3

4

7

9

3

v1

v2

v3

v4

v5

v6

v7

Dynamic Trees

simple paths maintaining costs2
Simple Paths: Maintaining Costs
  • Costs:
    • addcost: constant time (just add to root)
    • Finding cost(x)is slightly harder: O(depth(x)).

actual costs

9

v6

difference form

9

v6

2

v2

3

v7

-7

v2

-6

v7

6

v1

4

v4

4

v1

2

v4

3

v3

7

v5

-1

v3

3

v5

costs:

6

2

3

4

7

9

3

v1

v2

v3

v4

v5

v6

v7

Dynamic Trees

simple paths finding minima
Simple Paths: Finding Minima
  • Still have to implement findmin:
    • Store mincost(x), theminimum cost on subpath with root x.
      • findmin runs in O(log n) time, but addcost is linear.

actual costs

9

v6

mincost

2

v6

2

v2

3

v7

2

v2

3

v7

6

v1

4

v4

6

v1

3

v4

3

v3

7

v5

3

v3

7

v5

costs:

6

2

3

4

7

9

3

v1

v2

v3

v4

v5

v6

v7

Dynamic Trees

simple paths finding minima1
Simple Paths: Finding Minima
  • Store min(x) = cost(x)–mincost(x) instead.
    • findmin still runs in O(log n) time, addcost now constant.

actual costs

9

v6

mincost

2

v6

min

7

v6

2

v2

3

v7

2

v2

3

v7

0

v2

0

v7

6

v1

4

v4

6

v1

3

v4

0

v1

1

v4

3

v3

7

v5

3

v3

7

v5

0

v3

0

v5

costs:

6

2

3

4

7

9

3

v1

v2

v3

v4

v5

v6

v7

Dynamic Trees

simple paths data fields
Simple Paths: Data Fields
  • Final version:
    • Stores min(x) and cost(x) for every vertex

actual costs

9

v6

(cost, min)

(9, 7)

v6

2

v2

3

v7

(-7,0)

v2

(-6,0)

v7

6

v1

4

v4

(4,0)

v1

(2,0)

v4

3

v3

7

v5

(1,0)

v3

(3,0)

v5

costs:

6

2

3

4

7

9

3

v1

v2

v3

v4

v5

v6

v7

Dynamic Trees

simple paths structural changes
Simple Paths: Structural Changes
  • Concatenating and splitting paths:
    • Join or split the corresponding binary trees;
    • Time proportional to tree height.
    • For balanced trees, this is O(log n).
      • Rotations must be supported in constant time.
      • We must be able to update min and cost.

Dynamic Trees

simple paths structural changes1
Simple Paths: Structural Changes
  • Restructuring primitive: rotation.
  • Fields are updated as follows (for left and right rotations):
    • cost’(v) = cost(v) + cost(w)
    • cost’(w) = –cost(v)
    • cost’(b) = cost(v) + cost(b)
    • min’(w) = max{0, min(b) – cost’(b), min(c) – cost(c)}
    • min’(v) = max{0, min(a) – cost(a), min’(w) – cost’(w)}

w

v

rotate(v)

v

c

a

w

a

b

b

c

Dynamic Trees

splaying
Splaying
  • Simpler alternative to balanced binary trees: splaying.
    • Does not guarantee that trees are balanced in the worst case.
    • Guarantees O(log n) access in the amortized sense.
    • Makes the data structure much simpler to implement.
  • Basic characteristics:
    • Does not require any balancing information;
    • On an access to v, splay on v:
      • Moves v to the root;
      • Roughly halves the depth of other nodes in the access path.
    • Based entirely on rotations.
  • Other operations (insert, delete, join, split) use splay.

Dynamic Trees

splaying1
Splaying
  • Three restructuring operations:

z

x

y

y

z

D

zigzag(x)

A

B

C

D

x

A

z

x

B

C

y

y

D

A

zigzig(x)

x

C

z

B

A

B

C

D

y

x

zig(x)

x

y

C

A

A

B

B

C

(only happens if y is root)

Dynamic Trees

an example of splaying
An Example of Splaying

h

g

I

f

H

e

A

d

G

c

B

b

C

a

D

E

F

Dynamic Trees

an example of splaying1
An Example of Splaying

h

h

g

g

I

I

f

f

H

H

e

e

A

A

d

zigzig(a)

d

G

G

c

a

B

B

b

b

C

F

a

c

D

E

E

F

C

D

Dynamic Trees

an example of splaying2
An Example of Splaying

h

g

I

f

H

e

A

d

G

a

B

b

F

c

E

C

D

Dynamic Trees

an example of splaying3
An Example of Splaying

h

h

g

g

I

I

f

f

H

H

a

e

A

A

d

e

zigzag(a)

d

G

b

a

B

F

G

B

c

b

E

F

c

C

D

E

C

D

Dynamic Trees

an example of splaying4
An Example of Splaying

h

g

I

f

H

a

A

d

e

b

B

F

G

c

E

C

D

Dynamic Trees

an example of splaying5
An Example of Splaying

h

h

g

a

I

I

f

f

H

g

a

A

A

d

e

H

d

e

zigzag(a)

b

B

F

G

b

B

F

G

c

E

c

E

C

D

C

D

Dynamic Trees

an example of splaying6
An Example of Splaying

h

a

I

f

g

A

d

e

H

b

B

F

G

c

E

C

D

Dynamic Trees

an example of splaying7
An Example of Splaying

a

h

f

h

a

I

d

g

f

A

I

g

b

e

B

H

A

d

e

H

c

zig(a)

E

F

G

b

B

F

G

C

D

c

E

C

D

Dynamic Trees

an example of splaying8
An Example of Splaying

a

f

h

d

g

A

I

b

e

B

H

c

E

F

G

C

D

Dynamic Trees

an example of splaying9
An Example of Splaying
  • End result:

h

a

g

f

h

I

f

d

g

H

A

I

e

b

e

A

B

H

d

splay(a)

c

G

E

F

G

c

B

C

D

b

C

a

D

E

F

Dynamic Trees

amortized analysis
Amortized Analysis
  • Bounds the running time of a sequence of operations.
  • Potential function maps each configuration to real number.
  • Amortized time to execute each operation:
    • ai = ti + i– i –1
      • ai: amortized time to execute i-th operation;
      • ti: actual time to execute the operation;
      • i: potential after the i-th operation.
  • Total time for m operations:

i=1..mti = i=1..m(ai+ i –1–i) = 0 –m + i=1..mai

Dynamic Trees

amortized analysis of splaying
Amortized Analysis of Splaying
  • Definitions:
    • s(x): size of node x (number of descendants, including x);
      • At most n, by definition.
    • r(x): rank of node x, defined as log s(x);
      • At most log n, by definition.
    • i: potential of the data structure (twice the sum of all ranks).
      • At most O(n log n), by definition.
  • Access Lemma [ST85]: The amortized time to splay a tree with root t at a node x is at most

6(r(t)–r(x)) + 1 = O(log(s(t)/s(x))).

Dynamic Trees

proof of access lemma
Proof of Access Lemma
  • Access Lemma [ST85]: The amortized time to splay a tree with root t at a node x is at most

6(r(t)–r(x)) + 1 = O(log(s(t)/s(x))).

  • Proof idea:
    • ri(x) = rank of x after the i-th splay step;
    • ai = amortized cost of the i-th splay step;
    • ai 6(ri(x)–ri–1(x)) + 1 (for the zig step, if any)
    • ai 6(ri(x)–ri–1(x)) (for any zig-zig and zig-zag steps)
    • Total amortized time for all k steps:

i=1..kai i=1..k-1 [6(ri(x)–ri–1(x))] + [6(rk(x)–rk–1(x)) + 1]

= 6rk(x) – 6r0(x) + 1

Dynamic Trees

proof of access lemma splaying step
Proof of Access Lemma: Splaying Step
  • Zig-zig:

Claim: a 6 (r’(x) – r(x))

t + ’–  6 (r’(x) – r(x))

2 + 2(r’(x)+r’(y)+r’(z))– 2(r(x)+r(y)+r(z)) 6 (r’(x) – r(x))

1+ r’(x) + r’(y) + r’(z) – r(x) – r(y) – r(z) 3 (r’(x) – r(x))

1 + r’(y) + r’(z) – r(x) – r(y) 3 (r’(x) – r(x)) since r’(x) = r(z)

1 + r’(y) + r’(z) – 2r(x) 3 (r’(x) – r(x)) since r(y) r(x)

1 + r’(x) + r’(z) – 2r(x) 3 (r’(x) – r(x)) since r’(x) r’(y)

(r(x) – r’(x)) + (r’(z) – r’(x))  –1 rearranging

log(s(x)/s’(x)) + log(s’(z)/s’(x))  –1 definition of rank

TRUE because s(x)+s’(z)<s’(x): both ratios are smaller than 1, at least one is at most 1/2.

z

x

y

y

D

A

zigzig(x)

x

C

z

B

A

B

C

D

Dynamic Trees

proof of access lemma splaying step1
Proof of Access Lemma: Splaying Step
  • Zig-zag:

Claim: a 4(r’(x) – r(x))

t + ’– 4(r’(x) – r(x))

2 + (2r’(x)+2r’(y)+2r’(z)) – (2r(x)+2r(y)+2r(z))4(r’(x) – r(x))

2 + 2r’(y) + 2r’(z) – 2r(x) – 2r(y)4(r’(x) – r(x)), since r’(x) = r(z)

2 + 2r’(y) + 2r’(z) – 4r(x)4(r’(x) – r(x)), since r(y) r(x)

(r’(y) – r’(x)) + (r’(z) –r’(x))  –1, rearranging

log(s’(y)/s’(x)) + log(s’(z)/s’(x))  –1 definition of rank

TRUE because s’(y)+s’(z)<s’(x): both ratios are smaller than 1, at least one is at most 1/2.

z

x

y

y

z

D

zigzag(x)

A

B

C

D

x

A

B

C

Dynamic Trees

proof of access lemma splaying step2
Proof of Access Lemma: Splaying Step
  • Zig:

Claim: a 1 + 6(r’(x) – r(x))

t + ’– 1 + 6 (r’(x) – r(x))

1 + (2r’(x)+2r’(y)) – (2r(x)+2r(y))1 + 6(r’(x) – r(x))

1 + 2 (r’(x) – r(x)) 1 +6(r’(x) – r(x)), since r(y) r’(y)

TRUE because r’(x) r(x).

y

x

zig(x)

x

y

C

A

A

B

B

C

(only happens if y is root)

Dynamic Trees

splaying2
Splaying
  • To sum up:
    • No rotation: a = 1
    • Zig: a 6(r’(x) – r(x)) + 1
    • Zig-zig: a 6(r’(x) – r(x))
    • Zig-zag: a 4(r’(x) – r(x))
    • Total amortized time at most 6 (r(t) – r(x)) + 1 = O(log n)
  • Since accesses bring the relevant element to the root, other operations (insert, delete, join, split) become trivial.

Dynamic Trees

dynamic trees5
Dynamic Trees
  • We know how to deal with isolated paths.
  • How to deal with paths within a tree?

Dynamic Trees

dynamic trees6
Dynamic Trees
  • Main idea: partition the vertices in a tree into disjoint solid paths connected by dashededges.

Dynamic Trees

dynamic trees7
Dynamic Trees
  • Main idea: partition the vertices in a tree into disjoint solid paths connected by dashededges.

Dynamic Trees

dynamic trees8
Dynamic Trees
  • A vertex v is exposed if:
    • There is a solid path from v to the root;
    • No solid edge enters v.

Dynamic Trees

dynamic trees9
Dynamic Trees
  • A vertex v is exposed if:
    • There is a solid path from v to the root;
    • No solid edge enters v.
  • It is unique.

v

Dynamic Trees

dynamic trees10
Dynamic Trees
  • Solid paths:
    • Represented as binary trees (as seen before).
    • Parent pointer of root is the outgoing dashed edge.
    • Hierarchy of solid binary trees linked by dashed edges: “virtual tree”.
  • “Isolated path” operations handle the exposed path.
    • The solid path entering the root.
    • Dashed pointers go up, so the solid path does not “know” it has dashed children.
  • If a different path is needed:
    • expose(v): make entire path from v to the root solid.

Dynamic Trees

virtual tree an example
Virtual Tree: An Example

a

b

f

c

b

d

l

f

c

e

g

q

i

a

i

h

p

k

j

l

j

h

m

k

o

p

q

n

m

e

r

s

n

o

d

t

r

t

g

v

u

s

v

w

u

w

virtual tree

actual tree

Dynamic Trees

dynamic trees11
Dynamic Trees
  • Example: expose(v)

v

Dynamic Trees

dynamic trees12
Dynamic Trees
  • Example: expose(v)
    • Take all edges in the path to the root, …

v

Dynamic Trees

dynamic trees13
Dynamic Trees
  • Example: expose(v)
    • …, make them solid, …

v

Dynamic Trees

dynamic trees14
Dynamic Trees
  • Example: expose(v)
    • …make sure there is no other solid edge incident into the path.
      • Uses splice operation.

v

Dynamic Trees

exposing a vertex
Exposing a Vertex
  • expose(x): makes the path from x to the root solid.
  • Implemented in three steps:
    • Splay within each solid tree in the path from x to root.
    • Splice each dashed edge from x to the root.
      • splice makes a dashed become the left solid child;
      • If there is an original left solid child, it becomes dashed.
    • Splay on x, which will become the root.

Dynamic Trees

exposing a vertex an example
Exposing a Vertex: An Example
  • expose(a)

l

k

a

k

k

l

k

pass 1

f

f

pass 2

l

pass 3

j

j

b

l

b

b

j

i

i

f

i

g

g

e

e

a

h

a

e

i

h

c

h

g

c

j

c

d

d

g

d

f

h

e

d

c

b

a

(virtual trees)

Dynamic Trees

dynamic trees splice
Dynamic Trees: Splice
  • Additional restructuring primitive: splice.
    • Will only occur when z is the root of a tree.
  • Updates:
    • cost’(v) = cost(v) – cost(z)
    • cost’(u) = cost(u) + cost(z)
    • min’(z) = max{0, min(v) – cost’(v), min(x) – cost(x)}

z

z

splice(v)

u

v

w

x

v

u

w

x

Dynamic Trees

exposing a vertex running time
Exposing a Vertex: Running Time
  • Running time of expose(x):
    • proportional to initial depth of x;
    • x is rotated all the way to the root;
    • we just need to count the number of rotations;
      • will actually find amortized number of rotations: O(log n).
    • proof uses the Access Lemma.
      • s(x), r(x) and potential are defined as before;
      • In particular, s(x) is the size of the whole subtree rooted at x.
        • Includes both solid and dashed edges.

Dynamic Trees

exposing a vertex running time proof
Exposing a Vertex: Running Time (Proof)
  • k: number of dashed edges from x to the root t.
  • Amortized costs of each pass:
    • Splay within each solid tree:
      • xi: vertex splayed on the i-th solid tree.
      • amortized cost of i-th splay: 6(r’(xi)– r(xi)) + 1.
      • r(xi+1)  r’(xi), so the sum over all steps telescopes;
      • Amortized cost first of pass: 6(r’(xk)–r(x1)) + k6 log n + k.
    • Splice dashed edges:
      • no rotations, no potential changes: amortized cost is zero.
    • Splay on x:
      • amortized cost is at most 6 log n + 1.
      • x ends up in root, so exactly k rotations happen;
      • each rotation costs one credit, but is charged two;
      • they pay for the extra k rotations in the first pass.
  • Amortized number of rotations = O(log n).

Dynamic Trees

implementing dynamic tree operations
Implementing Dynamic Tree Operations
  • findcost(v):
    • expose v, return cost(v).
  • findroot(v):
    • expose v;
    • find w,the rightmost vertex in the solid subtree containing v;
    • splay at w and return w.
  • findmin(v):
    • expose v;
    • use cost and min to walk down from v to w, the last minimum-cost node in the solid subtree;
    • splay at w and return w.

Dynamic Trees

implementing dynamic tree operations1
Implementing Dynamic Tree Operations
  • addcost(v, x):
    • expose v;
    • add x to cost(v);
  • link(v,w):
    • expose v and w (they are in different trees);
    • set p(v)=w (that is, make v a middle child of w).
  • cut(v):
    • expose v;
    • add cost(v) to cost(right(v));
    • make p(right(v))=null and right(v)=null.

Dynamic Trees

extensions and variants
Extensions and Variants
  • Simple extensions:
    • Associate values with edges:
      • just interpret cost(v) as cost(v,p(v)).
    • other path queries (such as length):
      • change values stored in each node and update operations.
    • free (unrooted) trees.
      • implement evert operation, which changes the root.
  • Not-so-simple extension:
    • subtree-related operations:
      • requires that vertices have bounded degree;
      • Approach for arbitrary trees: “ternarize” them:
        • [Goldberg, Grigoriadis and Tarjan, 1991]

Dynamic Trees

alternative implementation
Alternative Implementation
  • Total time per operation depends on the data structure used to represent paths:
    • Splay trees: O(log n) amortized [ST85].
    • Balanced search tree: O(log2n) amortized [ST83].
    • Locally biased search tree: O(log n) amortized [ST83].
    • Globally biased search trees: O(log n) worst-case [ST83].
  • Biased search trees:
    • Support leaves with different “weights”.
    • Some solid leaves are “heavier” because they also represent subtrees dangling from it from dashed edges.
    • Much more complicated than splay trees.

Dynamic Trees

other data structures
Other Data Structures
  • Some applications require tree-related information:
    • minimum vertex in a tree;
    • add value to all elements in the tree;
    • linkand cut as usual.
  • ET-Trees can do that:
    • Henzinger and King (1995);
    • Tarjan (1997).

Dynamic Trees

et trees
ET-Trees
  • Each tree represented by its Euler tour.
    • Edge {v,w}:
      • appears as arcs (v,w) and (w,v)
    • Vertex v:
      • appears once as a self-loop (v,v):
      • used as an “anchor” for new links.
      • stores vertex-related information.
    • Representation is not circular: tour broken at arbitrary place.

e

a

d

c

b

(a,c)

(c,d)

d

(d,e)

e

(e,d)

(d,c)

c

(c,b)

b

(b,c)

(c,a)

a

Dynamic Trees

et trees1
ET-Trees
  • Consider link(v,w):
    • Create elements representing arcs (v,w) and (w,v):
    • Split and concatenate tours appropriately:
      • Original tours:
      • Final tour:
  • The cut operation is similar.

(v,w)

(w,v)

Lv

v

L’v

Lw

w

L’w

Lv

v

(v,w)

L’w

Lw

w

(w,v)

L’v

Dynamic Trees

et trees2
ET-Trees
  • Tours as doubly-linked lists:
    • Natural representation.
    • link/cut: O(1) time.
    • addcost/findmin: O(n) time.
  • Tours as balanced binary search trees:
    • link/cut: O(log n) time (binary tree join and split).
    • addcost/findmin:O(log n) time:
      • values stored in difference form.

Dynamic Trees

contractions
Contractions
  • ST-Trees [ST83, ST85]:
    • first data structure to handle paths within trees efficiently.
    • It is clearly path-oriented:
      • relevant paths explicitly exposed and dealt with.
  • Other approaches are based on contractions:
    • Original tree is progressively contracted until a structure representing only the relevant path (or tree) is left.

Dynamic Trees

contractions1
Contractions
  • Assume we are interested in the path from a to b:
    • Using only local information, how can we get closer to the solution?

a

b

Dynamic Trees

contractions2
Contractions
  • Consider any vertex v with degree 2 in the tree
  • Possibilities if v is neither a nor b:
    • a and b on same “side”: v is not in a…b.
    • If a and b on different sides: v belongs to path a…b.

v

u

w

Dynamic Trees

contractions3
Contractions
  • Consider any vertex v with degree 2 in the tree
  • Possibilities if v is neither a nor b:
    • a and b on same “side”: v is not in a…b.
    • If a and b on different sides: v belongs to path a…b.
  • We can replace (u,v) and (v,w) with a new edge (u,w):
    • This is a compressoperation.

u

w

Dynamic Trees

contractions4
Contractions
  • Consider any vertex v with degree 1 in the tree:
    • If v is neither a nor b,it is clearly not in a…b.

v

w

Dynamic Trees

contractions5
Contractions
  • Consider any vertex v with degree 1 in the tree:
    • If v is neither a nor b,it is clearly not in a…b.
    • We can simply eliminate (v,w), reducing the problem size.
      • This is a rake operation.

w

Dynamic Trees

contractions6
Contractions
  • A contraction-based algorithm:
    • Work in rounds;
    • In each round, perform some rakesand/orcompresses:
      • this will create a new, smaller tree;
      • moves within a round are usually “independent”.
    • Eventually, we will be down to a single element (vertex/edge) that represents a path (or the tree).

Dynamic Trees

path queries
Path Queries
  • Computing the minimum cost from a to b:

a

2

3

1

5

8

1

3

9

2

9

7

2

5

4

7

6

7

1

3

4

5

4

b

Dynamic Trees

path queries1
Path Queries
  • Computing the minimum cost from a to b:

a

2

3

1

5

8

1

3

9

2

9

7

2

5

4

7

6

7

1

3

4

5

4

b

Dynamic Trees

path queries2
Path Queries
  • Computing the minimum cost from a to b:

a

3

5

1

2

9

7

6

3

5

4

b

Dynamic Trees

path queries3
Path Queries
  • Computing the minimum cost from a to b:

a

3

5

1

2

9

7

6

3

5

4

b

Dynamic Trees

path queries4
Path Queries
  • Computing the minimum cost from a to b:

a

5

2

6

3

4

b

Dynamic Trees

path queries5
Path Queries
  • Computing the minimum cost from a to b:

a

5

2

6

3

4

b

Dynamic Trees

path queries6
Path Queries
  • Computing the minimum cost from a to b:

a

2

4

b

Dynamic Trees

path queries7
Path Queries
  • Computing the minimum cost from a to b:

a

2

4

b

Dynamic Trees

path queries8
Path Queries
  • Computing the minimum cost from a to b:

a

2

b

Dynamic Trees

contractions7
Contractions
  • Suppose a definition of independence guarantees that a fraction 1/kof all possible rakes and compresseswill be executed in a round.
    • All degree-1 vertices are rake candidates.
    • All degree-2 vertices are compresscandidates.
    • Fact: at least half the vertices in any treehave degree 1 or 2.
    • Result: a fraction 1/2kof all vertices will be removed.
    • Total number of rounds is log(2k)/(2k-1)n = O(log n).

Dynamic Trees

contractions8
Contractions
  • rakeand compressproposed by Miller and Reif [1985].
    • Original context: parallel algorithms.
    • Perform several operations on trees in O(log n) time.

Dynamic Trees

the update problem
The Update Problem
  • Coming up with a definition of independence that results in a contraction with O(log n) levels.
    • But that is not the problem we need to solve.
  • Essentially, we want to repair an existing contraction after a tree operation (link/cut).
  • So we are interested in the update problem:
    • Given a contraction C of a forest F, find another contractionC’ of a forest F’ that differs from F in one single edge (inserted or deleted).
    • Fast: O(log n) time.

Dynamic Trees

our problem
Our Problem
  • Several data structures deal with this problem.
    • [Frederickson, 85 and 97]: Topology Trees;
    • [Alstrup et al., 97 and 03]: Top Trees;
    • [Acar et al. 03]: RC-Trees.

Dynamic Trees

top trees
Top Trees
  • Proposed by Alstrup et al. [1997,2003]
  • Handle unrooted (free) trees with arbitrary degrees.
  • Key ideas:
    • Associate information with the edges directly.
    • Pair edges up:
      • compress:combines two edges linked by a degree-two vertex;
      • rake: combines leaf with an edge with which it shares an endpoint.
      • All pairs (clusters) must be are disjoint.
    • expose: determines which twovertices are relevant to the query (they will not be rakedor compressed).

Dynamic Trees

top trees1
Top Trees
  • Consider some free tree.

(level zero: original tree)

Dynamic Trees

top trees2
Top Trees
  • All degree-1 and degree-2 vertices are candidates for a move (rakeor compress).

(level zero: original tree)

Dynamic Trees

top trees3
Top Trees
  • When two edges are matched, they create new clusters, which are edge-disjoint.

(level zero: original tree)

Dynamic Trees

top trees4
Top Trees
  • Clusters are new edges in the level above:
    • New rakes and compresses can be performed as before.

(level one)

Dynamic Trees

top trees5
Top Trees
  • The top tree itself represents the hierarchy of clusters:
    • original edge: leaf of the top tree (level zero).
    • two edges/clusters are grouped by rake or compress:
      • Resulting cluster is their parent in the level above.
    • edge/cluster unmatched: parent will have only one child.
  • What about values?

Dynamic Trees

top trees6
Top Trees
  • Alstrup et al. see top tree as an API.
  • The top tree engine handles structural operations:
    • User has limited access to it.
  • Engine calls user-defined functions to handle values properly:
    • join(A,B,C): called when A and B are paired (by rake or compress) to create cluster C.
    • split(A,B,C): called when a rakeor compressis undone (and C is split into A and B).
    • create(C, e): called when base cluster C is created to represent edge e.
    • destroy(C): called when base cluster C is deleted.

Dynamic Trees

top trees7
Top Trees
  • Example (path operations: findmin/addcost)
    • Associate two values with each cluster:
      • mincost(C): minimum cost in the path represented by C.
      • extra(C): cost that must be added to all subpaths of C.
    • create(C, e): (called when base cluster C is created)
      • mincost(C) = cost of edge e.
      • extra(C) = 0
    • destroy(C): (called when base cluster C is deleted).
      • Do nothing.

Dynamic Trees

top trees8
Top Trees
  • Example (path operations: findmin/addvalue)
    • join(A,B,C): (called when A and B are combined into C)
      • compress:mincost(C) = min{mincost(A), mincost(B)}
      • rake:mincost(C) = mincost(B)(assume A is the leaf)
      • Both cases: extra(C) = 0
    • split(A,B,C): (calledwhen C is split into A and B)
      • compress:for each child X{A,B}:
        • mincost(X) = mincost(X) + extra(C)
        • extra(X) = extra(X) + extra(C)
      • rake:same as above, but only for the edge/cluster that was not raked.

Dynamic Trees

top trees9
Top Trees
  • Example (path operations: findmin/addvalue)
    • To find the minimum cost in path a…b:
      • R = expose(a, b);
      • return mincost(R).
    • To add a costx to all edges in path a…b:
      • R = expose(a, b);
      • mincost(R) = mincost(R) + x;
      • extra(R) = extra(R) + x.

Dynamic Trees

top trees10
Top Trees
  • Can handle operations such as:
    • tree costs (just a different way of handling rakes);
    • path lengths;
    • tree diameters.
  • Can handle non-local information using the select operation:
    • allows user to perform binary search on top tree.
    • an example: tree center.
  • Top trees are implemented on top of topology trees, which they generalize.

Dynamic Trees

topology trees
Topology Trees
  • Proposed by Frederickson [1985, 1997].
  • Work on rooted trees of bounded degree.
    • Assume each vertex has at most two children.
      • Values (and clusters) are associated with vertices.
    • Perform a maximal set of independent moves in each round.
    • Handle updates in O(log n) worst-case time.

Dynamic Trees

rc trees
RC-Trees
  • Proposed by Acar et al. [2003].
  • Can be seen as a variant of topology trees.
    • Information stored on vertices.
    • Trees of bounded degree.
  • Main differences:
    • Not necessarily rooted.
    • Alternate rakeand compressrounds.
    • Not maximal in compressrounds (randomization).
    • Updates in O(log n) expectedtime.

Dynamic Trees

contractions9
Contractions
  • Topology, Top, and Trace trees:
    • contraction-based.
  • ST-Trees: path-based.
    • But there is a (rough) mapping:
      • dashed rake
        • “this is a path that goes nowhere”
      • solid compress
        • “both part of a single path”
    • ST-Trees can be used to implement topology trees [AHdLT03].

Dynamic Trees

chronology
Chronology
  • ST-Trees:
    • Sleator and Tarjan (1983): with balanced and biased search trees;
    • Sleator and Tarjan (1985): splay trees.
  • Topology Trees:
    • Frederickson (1985, 1987).
  • ET-trees:
    • Hensinger and King (1995);
    • Tarjan (1997).
  • Top Trees:
    • Alstrup, de Lichtenberg, and Thorup (1997);
    • Alstrup, Holm, de Lichtenberg, and Thorup (2003).
  • RC-Trees:
    • Acar, Blelloch, Harper, and Woo (2003).

Dynamic Trees