1 Algorithmic Aspects of Searching in the Past Thomas Ottmann Institut für Informatik, Universität Freiburg, Germany [email protected]

1

Algorithmic Aspects of Searching in the Past

Thomas OttmannInstitut für Informatik, Universität Freiburg, Germany

[email protected]

(Lecture 13: Persistence and Oblivious Data Structures)Advanced Algorithms & Data Structures

mailto:[email protected]

2

Overview

• Motivation: Oblivious and persistent structures

• Examples: Arrays, search trees, Z-stratified search trees, relaxation

• Making structures persistent: Structure-copying, path-copying-, DSST-method

• Application: Pointlocation

• Application: Time-evolving data: Capture and replay of whiteboard data,

in particular handwriting traces

• Oblivious structures: Randomized and uniquely represented structures, c-level

jump lists

3

Motivation

A structure storing a set of keys is called oblivious, if it is not possible to infer its

generation history from its current shape.

A structure is called persistent, if it supports access to multiple versions.

Partially persistent: All versions can be accessed but only the newest version can be

modified.

Fully persistent: All versions can be accessed and modified.

Confluently persistent: Two or more old versions can be combined into one new

version.

4

Example: Arrays

Array:

2 4 8 15 17 43 47 ……

Uniquely represented structure, hence, oblivious!

Access: In time O(log n) by binary search.

Update (Insertion, Deletion): (n)

Caution:Storage structure may still depend on generation history!

5

Example: Natural search trees

Only partially oblivious!

• Insertion history can sometimes be reconstructed.

• Deleted keys are not visible.

Access, insertion, deletion of keys may take time (n)

1, 3, 5, 7 5, 1, 3, 7

13

57 3

1

5

7

6

Example: Balanced search tree

Problem:Updates come in sudden bursts (Example: Recording ink-traces from pen input)Not enough time to serialize insertions and rebalancing transformationsSolution:Relaxed balancing: Carry out updates and rebalancing transformations concurrently!

10

6 15

2 9 11 23

5 7 20 30

6 7 9

10 11 15

5

2

20 23

7

Stratified search trees

....

…..

… …

… …

8

Example

9

Example

10

Insertion

Insert the new key among the leaves at the expected positionand deposit a „push-up-request“

… …

… … ....

…..

…..

x p

11

Iterative sequence of insertions

12

Handling of push-up-requests (1)

• A push-up-request either leads to a local structural change and halt, which can be

carried out in time O(1) (Case 1)

• or (exclusively) to a recursive shift of the push-up-requests to the next higher

stratum without any structural change (Case 2)

Case 1 [There is still room on the next higher stratum]

1 2 31 2

3

1 2

3 4 1 2 3 4

1

2 3

4 2 31 4

13

Handling of push-up-requests (2)

Case 2 [Next higher stratum is full]

Append a new apex, if node is pushed over topmost stratum boarder

1

2 3

4 5 1

2 3

4 5

14

Deletion

Locate x among the leaves.Deposit a removal request at x.Handle removal request.

… …

… … ....

…..

… …

15

Handling removal requests

Case 1 [Enough nodes at bottommost stratum]

Case 2 [Bottommost stratum too sparse]

Deposit „pull-down-request“ p q q

16

Handling of pull-down-requests (1)

1p 2 3 1p 2 3

1p 2 3 4 p 1 2 3 41 p2 3 4

1 2 3 4p

Case1 [There are enough nodes on next higher stratum]

Finite structural change andHalt!

17

Handling of pull-down-requests (2)

p

qq

p

Case 2 [Not enough nodes on next higher stratum]

Recursively shift pull-down-request to next higher stratum,but no structural change!

18

Z-stratified search trees: Observations

Insertions, deletions, and rebalancing-transformations (removal of , ) can be

arbitrarily interleaved.

The amortized restructuring costs per insertion or deletion are constant.

The generation history of a current version may be partially reconstructed (Sequence

of insertions and deletions are partially visible)

But:

• Update operations are always applied to the current version

• Z-stratified search trees are not persistent

19

Overview








jump lists

20

Simple methods for making structures persistent

• Copy structure and apply an update-operation to the copy, yields fully persistence

at the price of (n) time per update and space (m n) for m updates applied to

structures of size n. (Structure-copying method)

• Do nothing, but store a log-file of all updates! In order to access version i, first carry

out i updates, starting with the initial structure, and generate version i. (i) time per

access, (m) space for m operations.

• Hybrid-method: Store the complete sequence of updates and additionally each k-th

version for a suitably chosen k. Result: Time and space requirement increases at

least with a faktor sqr(m) !

Are there any better methods? …. for search trees….

21

Persistent search trees (1)

Path-copying method

5

1 7

3

0

version 0:

22


Path-copying method

5 5

1 1 7

3 3

2

0 1

version 1:Insert (2)

23


Path-copying method

5 5 5

1 1 1 7

3 3 3

2 4

0 1 2

version 1:Insert (2)version 2:Insert (4)

24


Path-copying method

Restructuring costs: O(log n) per update operation

5 5 5

1 1 1 7

3 3 3

2 4

0 1 2


25


DSST-method: Extend each node by a time-stamped modification box

? All versionsbefore time t

All versionsafter time t

Modification boxes• initially empty• are filled bottom up

k

t: rplp rp

26

DSST method

5

1

3

7

version 0

27

DSST method

5

1

3

2

7

1 lp

version 0:

28

DSST method

5

1

3

2

3

4

7

1 lp


29

DSST method

The amortized costs (time and space) per update operation are O(1)

5

1

3

2

3

4

72 rp

1 lp


30

Overview








jump lists

31

Application: Planar Pointlocation

Suppose that the Euclidian plane is subdivided into polygons by n line segments that intersect only at their endpoints.

Given such a polygonal subdivision and an on-line sequence of query points in the plane, the planar point location problem, is to determine for each query point the polygon containing it.

Measure an algorithm by three parameters:

1) The preprocessing time.

2) The space required for the data structure.

3) The time per query.

32

Planar point location -- example

33


34

Solving planar point location (Cont.)

Partition the plane into vertical slabs by drawing a vertical line through each endpoint.

Within each slab the lines are totally ordered.

Allocate a search tree per slab containing the lines at the leaves with each line associate the polygon above it.

Allocate another search tree on the x-coordinates of the vertical lines

35

Solving planar point location (Cont.)

To answer query

first find the appropriate slab

then search the slab to find the polygon

36


37

Planar point location -- analysis

Query time is O(log n)

How about the space ?

(n2)

And so could be the preprocessing time

38

Planar point location -- bad example

Total # lines O(n), and number of lines in each slab is O(n).

39

Planar point location & persistence

So how do we improve the space bound ?

Key observation: The lists of the lines in adjacent slabs are very similar.

Create the search tree for the first slab.

Then obtain the next one by deleting the lines that end at the corresponding vertex and adding the lines that start at that vertex

How many insertions/deletions are there alltogether ?

2n

40

Planar point location & persistence (cont)

Updates should be persistent since we need all search trees at the end.

Partial persistence is enough.

Well, we already have the path copying method, lets use it.What do we get ?

O(n logn) space and O(n log n) preprocessing time.

We can improve the space bound to O(n) by using the DSST method.

41

Overview








jump lists

42

Author Audience

Data sources

Lightweight

content creation

Recorded learning module Document

Input media• Whiteboard• TouchScreen• Tablet PC

Time evolving data: Presentation recording

43

Cintiq Tablet (Wacom)

• Pen input, large display

• Eye contact with audience

44

Random access facility

Access of an ink-object sj corresponding to time tj requires the immediate presentation

of sj and of all ink-objects since t0

45

Whiteboard data

Whiteboard data-stream requires

• Fast insertion and deletion of graphical objects (lines, circles, pen-traces, …) in

large quantities,

• Partially persistent storage which allows:

• Fast access (display and „rendering“) of all data for a given time stamp,

• Synchronisability (as slave) with audio-stream (master).

Problem: Find a suitable method for storing the whiteboard-action stream!

46

Postprocessing

Whiteboard-stream is made persistent by the structure-copying method:

For each time stamp t a complete list of all objects visible on the board at time t is (pre-)computed and stored for random access.

Disadvantage: Highly redundant, very large data-volume

Advantage: Visible scrolling

Storage and representation of freehand ink-traces: Find a suitable compromise between conflicting goals:

Data-volume

Access cost (time) and dynamic replay (visible scrolling)

Individual, personal style

Skalability (vector- vs. raster-based-representation)

47

Overview








jump lists

48

Methods for making structures oblivious

Unique representation of the structure:

• Set/size uniqueness: For each set of n keys there is exactly one structure which

can store such a set.

• The storage is order unique, i.e. the nodes of the strucure are ordered and the

keys are stored in ascending order in nodes with ascending numbers.

Randomise the structure:

Assure that the expectation for the occurrence of a structure storing a set M of

keys is independent of the way how M was generated.

Observation: The address-assingment of pointers has to be subject under a

randomised regime!

49

Example of a randomised structure

Z-stratified search tree

On each stratum, randomlychoose the distribution oftrees from Z.

Insertion?Deletion?

… …

… … ....

…..

…..

50

Uniquely represented structures

(a) Generation history determines structure

(b) Set-uniqueness:Set determines structure

1, 3, 5, 7 5, 1, 3, 7

1, 3, 5, 7

13

57

3

1

5

7

13

57

51

Uniquely represented structures

(c) Size-uniqueness:Size determines structure

1, 3, 5, 7

2, 4, 5, 8 Common structure

Order-uniqueness: Fixed ordering of nodes determines where the keys are to be stored.

1

3

2

4

2

4

5

8

1

3

5

7

52

Set- and order-unique structures

Lower bounds?

Assumptions: A dictionary of size n is represented by a graph of n nodes.

Node degree finite (fixed),

Fixed order of the nodes,

i-th node stores i-largest key.

Operations allowed to change a graph:

Creation | Removal of a node

Pointer change

Exchange of keys

Theorem: For each set- and order-unique representation of a dictionary with n keys, at

least one of the operations access, insertion, or deletion must require time (n1/3).

53

Uniquely represented dictionaries

Problem: Find set-unique oder size-unique representations of the ADT „dictionary“

Known solutions:

(1) set-unique, oder-unique

Aragon/Seidel, FOCS 1989: Randomized Search Trees

universal

hash-function

Update as for priority search trees!

Search, insert, delete can be carried out in O(log n) expected time.

(s, h(s))

priority

s Î X

54

The Jelly Fish

(2) L. Snyder, 1976, set-unique, oder-unique

Upper Bound: Jelly Fish, search insert delete in time O(n).

body: n nodes

n tentacles of length n each

10

5

1

2

3

6

7

8

11

12

55

Lower bound for tree-based structures

set-unique, oder-unique

Lower bound: For “tree-based” structures the following holds:

Update-time · Search-time = Ω (n)

Number of nodes n ≤ h L + 1

L ≥ (n – 1)/h

At least L-1 keys must have moved from leaves to internal nodes. Therefore, update requires time Ω(L).

Delete x1

Insert xn+1 > xn

L leaves

·

xnx1

h

56

Cons-structures

(3) Sunder/Tarjan, STOC 1990, Upper bound: (Nearly) full, binary search trees

Einzige erlaubte Operation für Updates:

Search time O(log n)

EinfügenEntfernen in Zeit O(n) möglich

·

··

·31 15 353

L Rx L R

x

Cons, ,

57

Jump-lists

(Half-dynamic) 2-level jump-list

2-level jump-liste of size n

niini 22 )1(

Search: O(i) = O( ) timeInsertion: Deletion: O( ) time

n

n

22 4113

tail

0 i 2i n

(n-1)/i · i

2 3 5 7 8 10 11 12 14 17 19

58

Jump-lists: Dynamization

2-level-jump-list of size n niini 22 )1(

22 4113

search: O(i) = O(n) timeinsert delete

: O(n) time

Can be made fully dynamic:

(i-1)2 i2 n (i+1)2 (i+2)2

tail

0 i 2i n

(n-1)/i · i

2 3 5 7 8 10 11 12 14 17 19

59

3-level jump-lists

33 )1( ini

33 43,30 nnin 3

level 2

Search(x): locate x by followinglevel-2-pointers identifying i2 keys among which x may occur,level-1-pointers identifying i keys among which x may occur,level-0-pointers identifying x

time: O(i) = O(n1/3)

0 i 2i i2 i2+i 2·i2

60

3-level jump-lists

33 )1( ini

33 43,30 nnin 3

level 2

Update requiresChanging of 2 pointers on level 0Changing of i pointers on level 1Changing of all i pointers onlevel 2

Update time O(i) = O(n1/3)

0 i 2i i2 i2+i 2·i2

61

c-level jump-lists

Let

Lower levels:

level 0: all pointers of length 1:

...

level j: all pointers of legth ij-1:

...

level c/2 : ...

Upper levels:

level j: connect in a in list all nodes

1, 1·ij-1+1, 2· ij-1+1, 3· ij-1+1, ...

level c:

cc ini )1(

62

c-level jump-lists

Theorem:

For each c ≥ 3, the c-level jump-list is a size and order-unique representation

of dictionaries with the following characteristics:

Space requirement O(c·n)

Access time O(c·n1/c)

Update time , if n is even

, if n is odd

)( nO

)( 2/)1( ccnO

63

1 top-level tree with n leavesAll low-level trees for each sequence of n consecutive keys

Top-level tree direct search to the root of the currently active low-level treesSemi-dynamic structure: )1(22 22 kk n

12,)12( kk rrsn

low-level-tree-sizes+1 = top-level-tree-size )( nO

Shared-search-trees

Reduction of search time

64

Shared-search-trees

Pointers at:

Level 0 : (p-20) p (p+ 20)

Level 1 : (p-21) p (p+ 21)

…

Level k-2 : (p-2k-2) p (p+ 2k-2)

2(k-1) Pointers per node p, k = O(log n)

Search time O(log n)Space O(n log n)

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

1

0

65

Insertion: Determine insertion position;Change all pointers jumping over the insertion position;Add 2 new pointers per level;Completely rebuild top-level tree.

)1(22 22 kk n

0

1

66

Number of pointerchanges: level 0:

2·20+2level 1:

2·21+2…level k-2:

2·2k-2+2 2·(2k-1-1)+2(k-1) =

)nO(

)1(22 22 kk n

0

1

67

Shared search trees: Summary

Theorem: Shared search trees are a size- und order-unique representation of

dictionaries with the following characteristics:

Space requirement: O(n log n)

Search time: O(log n)

Upadate time: O( n )

Open problem:

Is there a size- and order-unique representation of by graphs with bounded node

degree, search time O(log n), and update time o(n) (e.g.. O(n))?

Documents

1 Algorithmic Aspects of Searching in the Past Thomas Ottmann Institut für Informatik, Universität Freiburg, Germany [email protected]