Dynamic Segment Trees and Union Copy Stuctures

Computational Geometry, WS 2006/07Lecture 19

Prof. Dr. Thomas Ottmann

Algorithmen & Datenstrukturen, Institut für InformatikFakultät für Angewandte WissenschaftenAlbert-Ludwigs-Universität Freiburg

2

Traditional Segment Trees

3

Segment Trees - motivation

When one wants to inspect a small portion of a large and complex objects.

Example:– GIS: windowing query in a map - given a detailed map

contains enormous amount of data, the system has to determine efficiently the part of the map corresponding to a specified region (window).

4

Semi dynamic segment trees

• Let I = { [x1, x1’ ], [x2, x2’ ],, [xn, xn’ ] } be a set of n intervals.

• Let p1, p2,, pm be the list of distinct intervals endpoints, sorted from left to right. The elementary intervals are defined to be : (-, p1), [p1, p1], (p1, p2), [p2, p2],(pm,)

p1 p2pm

5

Constructing a segment tree

• A balanced binary tree T. The leaves of T correspond to the elementary intervals (ordered from left to right). The elementary interval in a leaf is denoted Int()

• The internal nodes of T correspond to the intervals that are the union of elementary intervals: Int(v) is the union of intervals of its two children.

6

Constructing a segment tree - cont.

• Each node or leaf v in T stores the interval Int(v) and a canonical set I(v) I of intervals. This set contains the intervals [x, x’] I s.t Int(v) [x, x’] and Inv(Parent(v)) [x, x’] .

• Lemma: A segment tree on a set of n intervals uses O(n log n) storage.

7

Segment tree- example

s1 s2s5

s3

s4

S5

S2, S5

S1

S1

S2, S5

S1S3

S4S3

S4, S3

p1 p2

p3 p4

p5

p6p7

8

Lemma - proof

T is a balances binary tree its height is O(log n).

Claim: any interval [x, x’] is stored in the set I(v) for at most two nodes at the same depth of T.

Proof: Let v1, v2, v3 be three nodes from left to right in same depth. Suppose [x, x’] is at v1 and v3. [x, x’] spans the interval from left point of Int(v1) to right point of Int(v3), v2 lies between v1, v3 Int(parent(v2)) [x, x’] .

9

Lemma - proof. Continue

Any interval is stored at most twice at a given depth of T.

The total amount of storage is O(n log n).

v1 v2 v3

10

Algorithm: Query Segment Tree(V,qx)

• Input: the root of a segment tree and a query point qx.

• Output: All intervals in the tree containing qx.

• Report all intervals in I(v).• If v is not a leaf

– then if qx Int(lc(v))

– then QuerySegmentTree(lc(v), qx)

– else QuerySegmentTree(rc(v), qx)

11

Algorithm: Query Segment Tree(V,qx) - Complexity.

• Visit O(log n) nodes in total.

• At each node v spend O(1 + kv) time.

The intervals containing a query point qx are reported in O(log n + k) time, where k is the number of reported intervals.

12

Algorithm:Constructing a segment tree.

• Sort the endpoints of the intervals and get the elementary intervals.

• Construct a balanced binary tree on the elementary intervals and determine Int(v) for each v. (bottom-up manner).

• Determine the canonical subsets : insert the intervals one by one to T.

13

Algorithm:Insert Segment Tree(V,[x,x’])

• Input: the root of a segment tree and an interval.• Output: The interval will be stored in tree.

If Inv(v) [ x, x’]

then store [ x, x’] at v.

else if Int(lc(v)) [ x, x’]

then InsertSegmentTree(lc(v), [ x, x’])

if Inv(rc(v)) [ x, x’] then InsertSegmentTree(rc(v), [ x, x’])

14

Algorithm: Insert Segment Tree(V,[x,x’]) - Complexity.

• An interval is stored at most twice at each level.• There is at most one node at every level whose interval

contains x (the same for x’).• Hence, We visit at most 4 nodes per level.

The insertion time is O(log n). Construction time is

O(n log n).

15

Union copy structures

16

Introduction

• Generalization of union-find problem: copy operation is also supported.

• The structure: A bipartite graph with two node sets V1, V2 and edges between them.

• V1 form the sets and V2 form the elements. An edge between v1V1 and v2 V2 indicates that v2 is a member element of the set v1.

17

Notations

• Let = {S1, Sm} be a collection of sets.

= {x1,, xn} be a collection of elements.

• The sets in are subsets of .

• Let x be the collection of sets that contain an element x.

18

The structure

Consists four ingredients:• Set nodes - .• Element nodes - .• Normal nodes - connect sets to elements.• Reversed nodes - connect elements to sets.

Whenever there is a path from a set node to an element node, the corresponding element is in the corresponding set.

19

The structure - continue.

The following invariant are maintained:• A set node has one outgoing edge.• An element node has one incoming edge.• A normal node has one incoming edge, and at least

two outgoing edges.• A reversed node has one outgoing edge and at least

two incoming edges.• No edge may go from a reversed node to another

reversed node.

20

The structure - continue.

• No edge may go from a normal node to another normal node.

• There is one unique path from a set node to an element node iff the element is in the set.

• Any path in the union-copy structure from a set node to an element node consists of an alternating sequence of normal and reversed nodes.

The union copy structure is acyclic.

21

The structure - example

set

normal

reversed

element

S1S2 S3 S4

S5

x1 x2 x3x4 x5

x6 x7 x8

22

Defining the operations.

• Set-create(S) - create a new empty set in with name S.

• Set-insert(Si, xj) - (defined when xj Si). make Si Si {xj}.

• Set-destroy(Si) - remove Si from .

• Set-find(Si) - report all elements in Si.

• Set-union(Si, Sj) - (defined when Si, Sj disjoint). Si Si Sj and Sj.

• Set-copy(Si, Sj) - (defined when Sj is empty). Sj Si.

23

Defining the operations. Continue

• Element-create(x) - create an element x in and x .

• Element-insert(xi, Sj) - (define when xi Sj) xi xi {Sj}.

• Element-destroy(xi) - remove xi from and from all its sets.

• Element-find(xi) - report all sets that contain xi.

• Element-union(xi, xj) - (defined when no set contains them both). Sxj, S S {xi}\{xj}, hence xi becomes xi xj and xj .

• Element-copy(xi, xj) - (defined when xj in no set). Puts xj in all sets containing xi.

24

Set-insert(S4,x2)

S1 S2 S3 S4 S5

x1 x2 x3x4 x5

x6 x7 x8

25

Set-destroy(S3)

x8

S1 S2 S4S5

x1 x2 x3x4 x5

x6 x7

S3

26

Set-union(S4,S1)

x8

S1 S2 S4S5

x1 x2 x3x4 x5

x6 x7

S3

27

Set-copy(S5, S6)

S1 S2 S3 S4S5

x1 x2 x3x4 x5

x6 x7 x8

S6

28

The structure - notations.

• N-UF is a union-find structure represents the normal nodes.Sets in N-UF normal nodes.Elements in N-UF outgoing edges.

• R-UF is a union-find structure represents the reversed nodes.Sets in N-UF reversed nodes.Elements in R-UF incoming edges.

29

Operations N-UF structure supports

• N-union(v,w) - Unite the edges of the v and w to become the edges of v. w looses its edges.

• N-find(ei) - Return the normal node of ei.

• N-add(v, ei) - Add edge ei to node v.

• N-delete(ei) - Delete ei from its origin.

• N-enumerate(v) - Return all outgoing edges of v.

30

The operations.

Set-find(Si)

• if out(Si) nil then Traverse(out(Si))

Traverse(e) • case type(dest(e)) of

– element: report the element as an answer.– normal: for all e’N-enumerate(dest(e)) do Traverse(e’ )– reversed: Traverse(out(R-find(e)))

31

Set-union(Si, Sj )

• if out(Si) nil or type(child(Si)) normal then exchange Si and Sj.

• if out(Sj) nil then ready.

• else if type(child(Si)) normal and type(child(Sj)) normal then N-union(child(Si), child(Sj))

• else if type(child(Si)) normal then N-add(child(Si), out(Sj))

• else // both are reversed or elements.make a normal node v.N-add(v, out(Si) ) ; N-add(v, out(Sj) )child(Si) v ; out(Sj) nil

32

Set-union - examples.

Si SjSi Sj

Si Sj SiSj

SiSi Sj

Sj

v

33

Set-copy(Si, Sj )

• if out(Si) nil then ready.

• else if type(child(Si))=reversed then R-add(R-find(out(Si)), out(Sj))

• else // type(child(Si))=normal or element.make a reversed node v.child(v) child(Si)R-add(v, out(Si)) R-add(v, out(Sj))

34

Set-copy - examples.

SiSi

Sj

Si SiSj

v

35

Set-insert(Si, xj)

• Make a new edge e

• if out(Si) nil then out(Si) e

• else if type(child(Si)) normal then N-add(child((Si), e)

• else // type(child(Si)) is reversed or element.Make a normal node vN-add(v, out(Si)) ; N-add(v, e)child(Si) = v

• // now e has an origin.

• if in(xj) nil then in(xj) e

• else if type(parent(xj)) reversed then R-add(parent(xj), e)

36

Set-insert(Si, xj) - continue

• else // type(parent(xj)) is normal or set.Make a reversed node w.R-add(w, in(xj) ); R-add(w, e)parent(xj) w

• // now e has a destination.

SiSi

xj

e

v

wxj

37

Set-destroy(Si)

• if out(Si) nil then case type(child(Si)) of

element: in(child(Si)) nil

reversed : Restore(out(Si) )

normal: for all eN-enumerate(child(Si)) doif type(dest(e))element then

in(dest(e)) nilelse //type(dest(e)) is

reversed.Restore(e)

• remove Si

38

Set-destroy(Si) - Restore(e)

• v R-find(e)• R-delete(e) from v• if v has only one incoming edge e’ then

if type(org(e’)) set or type(child(v)) element

thenout(v) e’

else // org(e’) and child(v) types are normal.w N-find(e’)for all e’’N-enumerate(child(v)) do

N-add(w, e’’ )remove child(v)remove v

39

Set-destroy(Si) - examples

Si

v

Si

v

e’

w

40

The analysis

TheoremGiven a collection of m sets and collection of n elements, a union copy

structure has the following performance:

set-create O(1) elm-create O(1)set-insert O(1) elm-insert O(1)

set-destroy O(1+ k (FN(n)+ FR(m))) elm-destroy O(1+ k (FR(m)+ FN(n)))

set-find O(1+ k FR(m)) elm-find O(1+ k FN(n))

set-union O(UN(n)) elm-union O(UR(m))

set-copy O(FR(m)) elm-copy O(FN(n))

41

Theorem - proof

Any normal node has out degree n.

Any reversed node has in degree m.

The operations N-find(R), N-enumerate(R) operate on sets of size O(n) ( O(m) ).

Proof for set-find:

If there are k answers, then there are O(k) normal nodes and reversed nodes that have been visited.

N-enumerate is linear with the degree of the node the total time spent on normal nodes is O(k).

The time to visit a reversed node is O(FR(m)).

At most O(1+kFR(m)) time is taken.

42

Dynamic Segment Trees

43

Dynamic segments trees - motivation

• With semi-dynamic data structures, new segments may be only inserted if their endpoints are chosen from a restricted universe.

• When using dynamic segments trees segments may be inserted and deleted freely. Split and concatenate operations are also provided.

44

Defining the operations.

• Create( T ) - (defined if T does not exist yet). Creates an empty tree T.

• Insert(T, [x1, x2]) - (defined if [x1, x2] T ). [x1, x2] is inserted to T.

• Delete(T, [x1, x2]) - (defined if [x1, x2] T ). [x1, x2] is deleted from T.

• Stabbing-query(T, y) - all segments [x1, x2] for which x1 y x2 are reported.

45

Defining the operations. Continue

• Concatenate(T1, T2, T) - (defined if the rightmost endpoint of a segment in T1 is less than the leftmost endpoint of a segment in T2 , and T is empty. It makes T T1 T2 . T1 and T2 are returned empty.

• Split(T, T1, T2, y) - (Defined if for all segments [x1, x2] in T either y x1 or x2 y, and T1, T2 are empty). It makes T1 {[x1, x2] ; x2 y}, T2 {[x1, x2] ; y x1}

T is returned empty.

46

Weak segment tree - definition.

• A w.s.t for a set S of segments consists of a binary tree T, with ordered elementary intervals in its leaves. Each node represents a subset of S, s.t sS we have:

– s is represented exactly once on every path from the root to a leaf, of which the elementary interval is contained in s.

– s is not represented on any other path from the root to a leaf.

A traditional segment tree is a w.s.t.

47

Weak segment tree - example.

I1,I2

I1=[1,3] I2=[2,3]

(-,1) [1,1] (1,2) [2,2] (2,3) [3,3] (3,-)

I1

I2

I1

I2

I2I1,I2I1

I1

I1

48

The union copy structure for dynamic segment trees

• Every node in T corresponds to a set in the union-copy structure.

• Every segment corresponds to an element.

The union-copy structure has O(n) sets and O(n) elements.

49

The union copy structure for dynamic segment trees. Continue

• We take for the N-UF a union-find structure. (O(1) time for N-union).

• For R-UF we take a structure in which R-find takes O(1) (UF(i) structure of La Poutre).

Allows :R-find in O(1),R-union in O((n)) amortized.

50

The structure.

The dynamic segment tree consists of:

• A week segment tree noted STT (RB tree).

Every node is augmented with an extra pointer to a set node of the union-copy structure.

• A union-copy structure.

• A dictionary tree (RB tree) noted DT, storing the set S of segments in its leaves, ordered on increasing (lexicography) left endpoint. Every leaf stores a segment which is an element node of the union-copy structure.

51

Why do we use a w.s.t?

S2

S2S1

S1v

u

After rotation right at v node u holds S2 – contradicts the

definition of a w.s.t!

u

vS1

S2

S2S1

S1

u

v

S2S1

S1S2

S1S2

52

Why do we use a w.s.t?

S2

S1v

u

u

v

S5S4

v

u

S3

53

The solution

The auxiliary operation Down().

Empty a set S by shifting ’s elements to both its children:

• Set-create(S’)

• Set-copy (S, S’)

• Set-union(Slchild(), S’)

• Set-union(Srchild(), S)

• Set-destroy(S’). // remove the empty set S’.

This operation will take O(1)!

54

Insert ([x1,x2],T)

• Add [x1,x2] to DT.

• NewEndpoint(x1, [x1,x2])

• NewEndpoint(x2, [x1,x2])

The node in STT where the paths to x1 and to x2 are split.

• for 1 on path from lchild() to leaf of x1 doif x1 is in left subtree of 1 then

Set-insert(Srchild(1), [x1,x2])

• for 2 on path from rchild() to leaf of x2 doif x2 is in left subtree of 2 then

Set-insert(Slchild(2), [x1,x2])

55

NewEndpoint (x, [x1,x2])

The leaf that contains x in STT.

• if Int() is an open interval (a,b) thenInt() [x,x]add (a,x) as a leaf ’ to STT add (x,b) as a leaf ’’ to STT Set-create(S’) ; Set-create(S’’) Set-copy(S, S’ ) ; Set-copy(S, S’’ )m() 0 ;

• Set-insert(S , [x1,x2]) ; m() m() +1

56

Insert ([x1,x2],T) - example

I1,I2

I1=[1,3] I2=[2,3]

(-,1) [1,1] (3,-)

I1

I2

Insert ( [1.5,2.5] )

[2,2](1.5,2)(1,1.5) [1.5,1.5] [3,3](2.5,3)(2,2.5) [2.5,2.5]

I3=[1.5,2.5]

I1

I3 I3

I3

I3

m()=1 m()=1

(1,2)(2,3)

57

Delete([x1,x2],T)

The leaf in DT that contains [x1,x2]

• Element-destroy()

• delete [x1,x2] from DT

• Remove-endpoint(x1)

• Remove-endpoint(x2)

58

Remove-endpoint(x)

The leaf in STT that contains x.

• m() m() - 1 • if m() = 0 then

// let Int(leaf left )=(a,x)// let Int(leaf right )=(x,b)Int() (a,b)delete from STT the leaf left of delete from STT the leaf right of

59

[1.5,1.5]

Delete ([x1,x2],T) - example

I1,I2

I1=[1,3] I2=[2,3]

(-,1) [1,1] (3,-)

I1

I2

Delete ( [1.5,2.5] )

(1.5,2)(1,1.5) (2.5,3)[2.5,2.5]

I3=[1.5,2.5]

I1I3 I3

I3

I3

m()=0 m()=0

(1,1.5) (1.5,2)

I3 I3

I3

I3

[2.5,2.5][1.5,1.5]

(1,2)(2.5,3)[2,2] (2,3)

[3,3](2,2.5)(2,2.5)

60

Concatenate(T1, T2 , T)

• if T1 is empty then T T2; ready

• if T2 is empty then T T1; ready

1 rightmost leaf of STT1 // let Int(1) = (x,)

2 leftmost leaf of STT2 // let Int(2) = (-,y)

• Int(1) = (x,y)

• delete 2 from STT2

• concatenate STT1 and STT2 to STT

• concatenate DT1 and DT2 to DT

61

Stabbing-query(T,y)

• for all nodes on the path STT to y do

Set-find(S)

62

The analysis

Lemma1: The operations insert and concatenate take O(log n) time on a dynamic segment tree that stores n segments, and this operations increase the space of the structure by at most O(log n).

63

The analysis - Continue.

Lemma2: Suppose the union copy-structure (as we chose) has O(nlog n) edges. Then O(n) Element-destroy operations take O(nlogn(n)) time.

64

The analysis - Continue.

Theorem:The operations insert and concatenate on the dynamic segment tree as described above for storing a set of n segments each take O(log n) amortized time. The delete operations take O(log n (n)) amortized time, and stabbing queries take O(log n + k) time.The structure requires O(nlog n) space and can be constructed in O(nlog n) time.