• Kd trees

Computaional Geometry

Summer semester 2020

Overview

• Intro and problem definition

• Kd trees

Overview

• Intro and problem definition

• Kd trees

• Range trees

• Fractional cascading

• Kd trees

• Range trees

Overview

• Intro and problem definition

• Fractional cascading

• Kd trees

• Range trees

• Priority search trees

tons sold last year

cocoa

The obvious applciation

tons sold last year sugar

cocoa Database of cakes.

Which cakes have

• sugar content [0.12,0.17]

• cocoa content [0.05,0.1]

• and sold btw. 3 and 4 tons

last year?

tons sold last year cocoa

Which cakes have

• sugar content [0.12,0.17]

• cocoa content [0.05,0.1]

• and sold btw. 3 and 4 tons last year?

Orthogonal range query

The obvious applciation

tons sold last year sugar

cocoa Database of cakes.

Which cakes have

• sugar content [0.12,0.17]

• cocoa content [0.05,0.1]

• and sold btw. 3 and 4 tons last year?

Orthogonal range query

Task: support such queries efficiently

3. on a Word RAM.

Problem definition

Given n points in Z

or Q

,

1. Preprocess them in O(n) e time and space to

2. support orthogonal range queries in poly(log n) + O(k) 3. on a Word RAM.

output size

3. on a Word RAM.

output size

Static: preprocess and answer queries

Dynamic: update insertions and deletions in poly(log(n))

The 1-dimensional problem

Query: [x, x

]

Report next until exceeds x

The 1-dimensional problem

Query: [x, x

]

Option 1. Use sorted array:

Binary search for x

Report next until exceeds x

Static

only

Report next until exceeds x

Static Option 2. Binary search tree:

7 5

3

1 10 16

8 7

8 5

3

1 10

The 1-dimensional problem

Query: [x, x

]

Option 1. Use sorted array:

Binary search for x

Report next until exceeds x

Static

only

Option 2. Binary search tree:

7 5

3

1 10 16

8 7

8 5

3 1

P in the leaves Query: [4, 11]

10

inner vertex = largest value in left child’s subtree

Search for x , reporting left child subtrees

Split(x, x

)

π(x) π (x

)

Answering a query

Binary search for Split(x, x

)

Search for x, reporting right child subtrees Search for x

, reporting left child subtrees

Dynamic solution in R ¹

Split(x, x

)

π(x) π (x

)

Space = O(n)

Search for x , reporting left child subtrees

Split(x, x

)

π(x) π (x

)

Space = O(n)

Preprocess = O(n log n)

Answering a query

Binary search for Split(x, x

)

Search for x, reporting right child subtrees Search for x

, reporting left child subtrees

Dynamic solution in R ¹

Split(x, x

)

π(x) π (x

)

Space = O(n)

Preprocess = O(n log n)

Update = O (log n)

Search for x , reporting left child subtrees

Split(x, x

)

π(x) π (x

)

Space = O(n)

Preprocess = O(n log n) Update = O (log n)

Query = O(log n + k)

Kd trees

Bentley 1975

Kd trees in R ²

Assume distinct x- and y-coords Idea:

p

p

p

p

p

p

p

p

p

p

`

p

p

p

p

p

p

p

p

p

p

`

`

Kd trees in R ²

Assume distinct x- and y-coords

Idea:

`

`

`

p

p

p

p

p

p

p

p

p

p

`

`

`

`

' median x-coordinate

`

`

`

`

`

`

`

p

p

p

p

p

p

p

p

p

p

`

`

`

`

`

`

`

`

Kd trees in R ²

Assume distinct x- and y-coords

Idea:

`

`

`

`

`

`

`

`

`

p

p

p

p

p

p

p

p

p

p

`

`

`

`

`

`

`

`

p

p

p

`

p

p

p

`

' median x-coordinate

`

`

`

`

`

`

`

`

`

p

p

p

p

p

p

p

p

p

p

`

`

`

`

`

`

`

`

p

p

p

p

p

p

p

p

p

p

`

`

Kd tree anatomy

Space: O(n)

Tree has O(log n) depth.

Preprocessing: use linear time median:

T (n) = 2T (n/2) + O(n) ⇒ O(n log n)

T (n) = 2T (n/2) + O(n) ⇒ O(n log n)

`

`

`

`

`

`

`

`

p

p

p

p

p

p

p

p

p

p

Each ` has a rectangular region

`

Kd tree anatomy

Space: O(n)

Tree has O(log n) depth.

Preprocessing: use linear time median:

T (n) = 2T (n/2) + O(n) ⇒ O(n log n)

`

`

`

`

`

`

`

`

p

p

p

p

p

p

p

p

p

p

Each ` has a rectangular region

`

reg (`

) = R

Child regions of `:

separated by `

Querying a kd tree

query

Report subtree if reg (`) ⊆ Q

Report subtree if reg (`) ⊆ Q

If reg (`) intersects ∂Q: check!

Querying a kd tree

query

Report subtree if reg (`) ⊆ Q If reg (`) intersects ∂Q: check!

Searching, reporting covered regions: O(log n + k)

Report subtree if reg (`) ⊆ Q If reg (`) intersects ∂Q: check!

Searching, reporting covered regions: O(log n + k)

How many regions can intersect ∂Q?

Regions interseted by the boundary

Claim. A vertical line intersects at most O( √

n) node regions.

I (n): vert. line intersects this many regions in kd tree of size n

`

lc(`)

I (n): vert. line intersects this many regions in kd tree of size n

Two grandchild regions are not in- tersected

`

lc(`)

Regions interseted by the boundary

Claim. A vertical line intersects at most O( √

n) node regions.

I (n): vert. line intersects this many regions in kd tree of size n

Two grandchild regions are not in- tersected

`

I (n) = 2 + 2I (n/4)

reg (`) and reg (leftchild(`)) Intersections in red subtrees

lc(`)

Kd tree query time

⇒ I (n) = O( √ n)

I (n) = 2 + 2I (n/4) = 2 + 2 · (2 + 2 · (. . . )) = 2 + 4 + · · · + 2

Q has ≤ 2 vertical and ≤ 2 horizontal sides

⇒ ∂Q intersects O( √

n) regions

⇒ I (n) = O( n)

Kd tree query time

Q has ≤ 2 vertical and ≤ 2 horizontal sides

⇒ ∂Q intersects O( √

n) regions

⇒ I (n) = O( √ n)

Orthogonal range queries of a 2-dim kd tree take O ( √

n + k) time.

I (n) = 2 + 2I (n/4) = 2 + 2 · (2 + 2 · (. . . )) = 2 + 4 + · · · + 2

Range tree in R ²

Binary search tree on x-xoordinates

Each node has a new BST for y-coords of descendant leaves

v

T (v ) BST on x

BST on descendants of v sorted for y-coord.

Auxiliary tree

v

T (v )

BST on descendants of v sorted for y-coord.

Construction:

• Presort on y-coord to array A Construct(v, A):

• Construct T (v ) using A

• Find median x, split A to A

, A

• Construct(lc(v ), A

), Construct(rc(v ), A

)

Auxiliary tree

Range tree in R ²

Binary search tree on x-xoordinates

Each node has a new BST for y-coords of descendant leaves

v

T (v ) BST on x

BST on descendants of v sorted for y-coord.

Construction:

• Presort on y-coord to array A Construct(v, A):

• Construct T (v ) using A

• Find median x, split A to A

, A

• Construct(lc(v ), A

), Construct(rc(v ), A

) O (n log n)

O(n) O(n)

Auxiliary tree

v

T (v )

BST on descendants of v sorted for y-coord.

Construction:

• Presort on y-coord to array A Construct(v, A):

• Construct T (v ) using A

• Find median x, split A to A

, A

• Construct(lc(v ), A

), Construct(rc(v ), A

) O (n log n)

O(n) O(n)

O(n log n)

Auxiliary tree

Querying a 2-dim range tree

Do 1-dim range query on x-coordiantes Find O(log n) reported subtree roots

π (x) π(x

)

Do 1-dim query on each of the O(log n) selected y-trees

π (x) π(x

)

Querying a 2-dim range tree

Do 1-dim range query on x-coordiantes Find O(log n) reported subtree roots

Do 1-dim query on each of the O(log n) selected y-trees

P

v

O(log n + k

) = O(log

n + k ) Total query time:

π (x) π(x

)

Do 1-dim query on each of the O(log n) selected y-trees

P

v

O(log n + k

) = O(log

n + k ) Total query time:

In R

, it gives O(log

n + k )

π (x) π(x

)

Querying a 2-dim range tree

Do 1-dim range query on x-coordiantes Find O(log n) reported subtree roots

Do 1-dim query on each of the O(log n) selected y-trees

P

v

O(log n + k

) = O(log

n + k ) Total query time:

In R

, it gives O(log

n + k ) But! space is up to Θ(n log

n)

π (x) π(x

)

Each level stores chunks of

a (d − 1)-dim range tree

Handling degeneracies

Composite numbers: a, b ∈ R → (a|b) Sorted lexicographically.

repalce p = (x, y ) with p

= ((x|y), (y|x)) for each p ∈ P

⇒ all first and second coords are distinct

⇒ all first and second coords are distinct Given query Q = [x, x

] × [y, y

], replace by

Q

=

(x| −∞), (x

|∞)

×

(y| −∞), (y

|∞)

Handling degeneracies

Composite numbers: a, b ∈ R → (a|b) Sorted lexicographically.

repalce p = (x, y ) with p

= ((x|y), (y|x)) for each p ∈ P

⇒ all first and second coords are distinct Given query Q = [x, x

] × [y, y

], replace by

Q

=

(x| −∞), (x

|∞)

×

(y| −∞), (y

|∞)

Observation.

p ∈ Q ⇔ p

∈ Q

Speeding up binary searches on subsets

2 3 5 8 13 21 34 55 89 92 95 99

8 13 34 55

2 92 95

Array and subarray, query [4, 45]

⇒ two binary searhces?

A

B

2 3 5 8 13 21 34 55 89 92 95 99

8 13 34 55

2 92 95

Add pointer from A[x] to the smallest in B larger than A[x]

A

B

Speeding up binary searches on subsets

2 3 5 8 13 21 34 55 89 92 95 99

8 13 34 55

2 92 95

Array and subarray, query [4, 45]

⇒ two binary searhces?

Add pointer from A[x] to the smallest in B larger than A[x]

N U LL A

B

2 3 5 8 13 21 34 55 89 92 95 99

8 13 34 55

2 92 95

Add pointer from A[x] to the smallest in B larger than A[x]

N U LL A

B

Binary search A, use pointer of smallest reported

Layered range trees in R ²

Idea:

Replace 2nd level BSTs for y-coords w/ sorted arrays A

+ 2 pointers per entry

At node v, array A

has:

At node v, array A

has:

• Points in decendant leafs of v sorted by y-coords

Layered range trees in R ²

Idea:

Replace 2nd level BSTs for y-coords w/ sorted arrays A

+ 2 pointers per entry

At node v, array A

has:

• Points in decendant leafs of v sorted by y-coords

• Each entry (a, b) ∈ A

has:

– Pointer to entry in A

with smallest y-coord ≥ b

– Pointer to entry in A

with smallest y-coord ≥ b

At node v, array A

has:

• Points in decendant leafs of v sorted by y-coords

• Each entry (a, b) ∈ A

has:

– Pointer to entry in A

with smallest y-coord ≥ b – Pointer to entry in A

with smallest y-coord ≥ b

2 3 5 8 13 21 34 55 89 92 95 99

8 13 34 55

2 92

A

5 21 89 95

3 99

y-coords of entries

A

A

Layered range trees in R ²

Idea:

Replace 2nd level BSTs for y-coords w/ sorted arrays A

+ 2 pointers per entry

At node v, array A

has:

• Points in decendant leafs of v sorted by y-coords

• Each entry (a, b) ∈ A

has:

– Pointer to entry in A

with smallest y-coord ≥ b – Pointer to entry in A

with smallest y-coord ≥ b

2 3 5 8 13 21 34 55 89 92 95 99

8 13 34 55

2 92

A

5 21 89 95

3 99

y-coords of entries

A

A

N U LL

At node v, array A

has:

• Points in decendant leafs of v sorted by y-coords

• Each entry (a, b) ∈ A

has:

– Pointer to entry in A

with smallest y-coord ≥ b – Pointer to entry in A

with smallest y-coord ≥ b

2 3 5 8 13 21 34 55 89 92 95 99

8 13 34 55

2 92

A

5 21 89 95

3 99

y-coords of entries

A

A

Layered range trees in R ²

Idea:

Replace 2nd level BSTs for y-coords w/ sorted arrays A

+ 2 pointers per entry

At node v, array A

has:

• Points in decendant leafs of v sorted by y-coords

• Each entry (a, b) ∈ A

has:

– Pointer to entry in A

with smallest y-coord ≥ b – Pointer to entry in A

with smallest y-coord ≥ b

2 3 5 8 13 21 34 55 89 92 95 99

8 13 34 55

2 92

A

5 21 89 95

3 99

y-coords of entries

A

A

N U LL

Querying a layered range tree

Query: [x, x

] × [y, y

]

Search top (x-)tree for x and x

.

At v = Split(x, x

), binary search for y in A

→ A

.f ind(y)

Stepping to lc(v ), follow left pointer from A

.f ind(y)

Stepping to lc(v ), follow left pointer from A

.f ind(y)

⇒ Maintaining position in A

at each step takes O(1) time!

If w is root of a selected subtree:

Reporting from T (w) can be done from A

in O(1 + k

) time.

Querying a layered range tree

Query: [x, x

] × [y, y

]

Search top (x-)tree for x and x

.

At v = Split(x, x

), binary search for y in A

→ A

.f ind(y) Stepping to lc(v ), follow left pointer from A

.f ind(y)

⇒ Maintaining position in A

at each step takes O(1) time!

If w is root of a selected subtree:

Reporting from T (w) can be done from A

in O(1 + k

) time.

Total query time: O(log n + k )

Priority search tree

Priority queue (insert, pop max) +

Binary search tree

Construction:

• root r stores point with max y-coord

med

(root) := median x-coordinate of P \ {r}

Priority search tree

Priority queue (insert, pop max) +

Binary search tree Construction:

• root r stores point with max y-coord

med

(root) := median x-coordinate of P \ {r}

• left subtree: points p ∈ P \ {r} with p

≤ med

(r)

Construction:

• root r stores point with max y-coord

med

(root) := median x-coordinate of P \ {r}

• left subtree: points p ∈ P \ {r} with p

≤ med

(r)

• right subtree: points p ∈ P \ {r } with p

> med

(r)

Priority search tree

Priority queue (insert, pop max) +

Binary search tree Construction:

• root r stores point with max y-coord

med

(root) := median x-coordinate of P \ {r}

• left subtree: points p ∈ P \ {r} with p

≤ med

(r)

• right subtree: points p ∈ P \ {r } with p

> med

(r)

Construction:

• root r stores point with max y-coord

med

(root) := median x-coordinate of P \ {r}

• left subtree: points p ∈ P \ {r} with p

≤ med

(r)

• right subtree: points p ∈ P \ {r } with p

> med

(r)

Priority search tree

Priority queue (insert, pop max) +

Binary search tree Construction:

• root r stores point with max y-coord

med

(root) := median x-coordinate of P \ {r}

• left subtree: points p ∈ P \ {r} with p

≤ med

(r)

• right subtree: points p ∈ P \ {r } with p

> med

(r)

Space: O(n)

Construction: O(n log n)

(x, y) (x

, y)

Answering 3-sided queries

Wlog queries of the type [x, x

] × [y, ∞]

(x, y) (x

, y)

To answer the query from root = v :

π (x) π (x

)

Report subtree of v :

O(1 + k

)

(x, y) (x

, y) π (x) π (x

)

Report subtree of v : O(1 + k

)

+ check each node stored

on the search paths!

Answering 3-sided queries

Wlog queries of the type [x, x

] × [y, ∞]

(x, y) (x

, y)

To answer the query from root = v :

Query time: O(log n + k )

π (x) π (x

)

Report subtree of v : O(1 + k

)

+ check each node stored

on the search paths!

Static Dynamic

s:O(n)

q:O (log

n + k log

n) or

s:O(n log log n),

q:O (log log n + k log log n) or

s:O (n log

n), q:O (log log n + k)

s:O (n log

n) q:O (

+ k) u:O (log

n)

Chan–Larsen–P˘ atras

cu Chan–Tsakalidis

amortized

Range searching axis-parallel intervals

→ intervals ending in Q:

range searching on endpoints

→ intervals ”crossing” Q?

range searching on endpoints

→ intervals ”crossing” Q?

if horizontal, they cross left

boundary of Q

Range searching axis-parallel intervals

→ intervals ending in Q:

range searching on endpoints

→ intervals ”crossing” Q?

if horizontal, they cross left boundary of Q

Given a vertical query segment, report all horizontal segments

it is crossing.

range searching on endpoints

→ intervals ”crossing” Q?

if horizontal, they cross left boundary of Q

Given a vertical query segment, report all horizontal segments it is crossing.

line

Range searching axis-parallel intervals

→ intervals ending in Q:

range searching on endpoints

→ intervals ”crossing” Q?

if horizontal, they cross left boundary of Q

Given a vertical query segment, report all horizontal segments it is crossing.

line

⇔ in R

, which intervals contain query point q?

right child left child

`

median x-coord

of endpoints

Interval trees (Edelsbrunner 1980 McCreight 1980)

right child left child

stored in root

` root has intervals intersected by `

sorted for left endpoints in a list (same for right)

median x-coord of endpoints

Preprocess: O(n log n)

Query ( R

): O(log n + k)

Space: O(n)

right child left child

`

median x-coord of endpoints

Preprocess: O(n log n)

Query ( R

): O(log n + k)

If segment query:

use priority search tree instead of list

Q

Space: O(n)