Graham’s scan (1972)

Convex hulls in R²

S´andor Kisfaludi-Bak

Computaional Geometry Summer semester 2020

Overview

Overview

• Problem definition

Overview

• Problem definition

• Computaitonal models, input and output

Overview

• Problem definition

• Naive algorithm

• Computaitonal models, input and output

Overview

• Problem definition

• Naive algorithm

• Graham’s scan

• Computaitonal models, input and output

Overview

• Problem definition

• Naive algorithm

• Graham’s scan

• Computaitonal models, input and output

• Chan’s algorithm

Convex hull

Notations, definitions

R^d is d-dimensional Euclidean space P = {p₁, . . . , p_n} set of n points

X ⊆ R^d is convex if for any p, q ∈ X we have pq ⊆ X

Convex hull

Notations, definitions

R^d is d-dimensional Euclidean space P = {p₁, . . . , p_n} set of n points

X ⊆ R^d is convex if for any p, q ∈ X we have pq ⊆ X

conv(P) =







minimum convex set containing P

intersection of convex sets containing P {α₁p₁ + · · · + α_np_n | α_i ≥ 0 and Pn

i=1 α_i = 1}

Convex hull:

Convex hull

Notations, definitions

R^d is d-dimensional Euclidean space P = {p₁, . . . , p_n} set of n points

X ⊆ R^d is convex if for any p, q ∈ X we have pq ⊆ X

conv(P) =







minimum convex set containing P

intersection of convex sets containing P {α₁p₁ + · · · + α_np_n | α_i ≥ 0 and Pn

i=1 α_i = 1}

P Convex hull:

Convex hull

Notations, definitions

R^d is d-dimensional Euclidean space P = {p₁, . . . , p_n} set of n points

X ⊆ R^d is convex if for any p, q ∈ X we have pq ⊆ X

conv(P) =







minimum convex set containing P

intersection of convex sets containing P {α₁p₁ + · · · + α_np_n | α_i ≥ 0 and Pn

i=1 α_i = 1}

P

conv(P) Convex hull:

Real RAM vs. Word RAM

Real RAM Word RAM

Real RAM vs. Word RAM

arbitrary real numbers words of size Θ(log n)

Real RAM Word RAM

Real RAM vs. Word RAM

arbitrary real numbers words of size Θ(log n)

no rounding/floor, no modulo realistic^∗operations (shifts, etc)

Real RAM Word RAM

Real RAM vs. Word RAM

arbitrary real numbers words of size Θ(log n)

no rounding/floor, no modulo realistic^∗operations (shifts, etc) Real inputs and outputs,

can extend with √

., ln(.)

Exact arithmetic for

rational inputs with + − ∗/

Real RAM Word RAM

Real RAM vs. Word RAM

arbitrary real numbers words of size Θ(log n)

no rounding/floor, no modulo realistic^∗operations (shifts, etc) Real inputs and outputs,

can extend with √

., ln(.)

Exact arithmetic for

rational inputs with + − ∗/

Unrealistic power Too restrictive?

Real RAM Word RAM

Convex hull: input and output

Input: Points with coordianate pairs (x, y) ∈ R² (e, π), (3, 3), (2.95, 2.9), (√

11, 3.05), (π, e)

p₁

p₂

p₃

p₅

p₄

Convex hull: input and output

Input: Points with coordianate pairs (x, y) ∈ R² (e, π), (3, 3), (2.95, 2.9), (√

11, 3.05), (π, e)

p₁

p₂

p₃

p₅

p₄ p₁, p₄, p₅, p₃

Output: ”corners” in clockwise order

smallest Q ⊆ P s.t. conv(Q) = conv(P)

Convex hull: input and output

Input: Points with coordianate pairs (x, y) ∈ R² (e, π), (3, 3), (2.95, 2.9), (√

11, 3.05), (π, e)

p₁

p₂

p₃

p₅

p₄ p₁, p₄, p₅, p₃

non-corner point on

bondary: not in output!

p₆ Output: ”corners” in clockwise order

smallest Q ⊆ P s.t. conv(Q) = conv(P)

Convex hull: input and output

Input: Points with coordianate pairs (x, y) ∈ R² (e, π), (3, 3), (2.95, 2.9), (√

11, 3.05), (π, e)

p₁

p₂

p₃

p₅

p₄ p₁, p₄, p₅, p₃

non-corner point on

bondary: not in output!

p₆ Output: ”corners” in clockwise order

smallest Q ⊆ P s.t. conv(Q) = conv(P)

Everything works with rational inputs on Word RAM!

Naive algorithm

Naive Algorithm

Suppose no 3 points on one line. (no collinear triples)

Naive Algorithm

Suppose no 3 points on one line. (no collinear triples)

p

p⁰

q

In O(1) time, decide if q is on left or right side of line pp⁰

sgn





p_x p_y 1 p⁰_x p⁰_y 1 q_x q_y 1





Naive Algorithm

Suppose no 3 points on one line. (no collinear triples)

p

p⁰

q

In O(1) time, decide if q is on left or right side of line pp⁰

sgn





p_x p_y 1 p⁰_x p⁰_y 1 q_x q_y 1





Naive Convex Hull in R² For each p, p⁰ ∈ P ,

check if all q ∈ P \ {p, p⁰} is on the left of line pp⁰. If yes, then p⁰ follows p in conv(P ).

Assemble and output the hull

Naive Algorithm

Suppose no 3 points on one line. (no collinear triples)

p

p⁰

q

In O(1) time, decide if q is on left or right side of line pp⁰

Running time: ⁿ₂

· (n − 2) · O(1) = O(n³) sgn





p_x p_y 1 p⁰_x p⁰_y 1 q_x q_y 1





Naive Convex Hull in R² For each p, p⁰ ∈ P ,

check if all q ∈ P \ {p, p⁰} is on the left of line pp⁰. If yes, then p⁰ follows p in conv(P ).

Assemble and output the hull

Graham’s scan (1972)

Graham’s Scan idea

Suppose points have distinct x-coordinates.

Let p₁, . . . , p_n: points sorted with increasing x-coordinates.

Graham’s Scan idea

Suppose points have distinct x-coordinates.

Let p₁, . . . , p_n: points sorted with increasing x-coordinates.

p₁, p_n are on convex hull

p₁ p_n

Graham’s Scan idea

Suppose points have distinct x-coordinates.

Let p₁, . . . , p_n: points sorted with increasing x-coordinates.

p₁, p_n are on convex hull

p₁ p_n

Upper hull

part of the hull after p₁ and before p_n in clockwise order

Lower hull

Graham’s Scan idea

Suppose points have distinct x-coordinates.

Let p₁, . . . , p_n: points sorted with increasing x-coordinates.

p₁, p_n are on convex hull

p₁ p_n

Upper hull

part of the hull after p₁ and before p_n in clockwise order

Lower hull Idea:

Add points left to right, update upper hull after each addition

Graham’s Scan: update

p₁

Right turn

p_i

Left turn

p₁

p_i

(p_i is below last hull segment) (p_i is above last hull segment)

Graham’s Scan: update

p₁

Right turn

Add p_i to the upper hull p_i

Left turn

p₁

p_i

(p_i is below last hull segment) (p_i is above last hull segment)

Graham’s Scan: update

p₁

Right turn

Add p_i to the upper hull p_i

Left turn

p₁

p_i

(p_i is below last hull segment) (p_i is above last hull segment)

Graham’s Scan: update

p₁

Right turn

Add p_i to the upper hull p_i

Add p_i but remove previous hull point until left turn disappears

Left turn

p₁

p_i

(p_i is below last hull segment) (p_i is above last hull segment)

Graham’s Scan: update

p₁

Right turn

Add p_i to the upper hull p_i

Add p_i but remove previous hull point until left turn disappears Similalrly for lower hull, after adding p_i:

while last three points of lower hull q, q⁰, p_i are a right turn:

remove the middle point q⁰

Left turn

p₁

p_i

(p_i is below last hull segment) (p_i is above last hull segment)

Graham’s Scan: pseudocode + runtime

Sort P by increasing x-coordinates Add p₁, p₂ to U and L

for i = 3 to n do

Add p_i to U and L

while last three pts of U form left turn do Remove pt preceding p_i from U

while last three pts of L form right turn do Remove pt preceding p_i from L

return L and reverse of U

Graham’s Scan: pseudocode + runtime

Sort P by increasing x-coordinates Add p₁, p₂ to U and L

for i = 3 to n do

Add p_i to U and L

while last three pts of U form left turn do Remove pt preceding p_i from U

while last three pts of L form right turn do Remove pt preceding p_i from L

return L and reverse of U Running time:

Sorting O(n log n)

Graham’s Scan: pseudocode + runtime

Sort P by increasing x-coordinates Add p₁, p₂ to U and L

for i = 3 to n do

Add p_i to U and L

while last three pts of U form left turn do Remove pt preceding p_i from U

while last three pts of L form right turn do Remove pt preceding p_i from L

return L and reverse of U Running time:

Sorting

Each p ∈ P is:

added once to U (same for L)

removed at most once from U (same for L)

O(n log n)

O(n) O(n) Triplets checked in While loop heads O(n)

Graham’s Scan: pseudocode + runtime

Sort P by increasing x-coordinates Add p₁, p₂ to U and L

for i = 3 to n do

Add p_i to U and L

while last three pts of U form left turn do Remove pt preceding p_i from U

while last three pts of L form right turn do Remove pt preceding p_i from L

return L and reverse of U Running time:

Sorting

Each p ∈ P is:

added once to U (same for L)

removed at most once from U (same for L)

O(n log n)

O(n) O(n) Triplets checked in While loop heads O(n)

Running time: O(n log n)

Graham’s Scan: correctness

Claim

After each iteration of main loop, U is upper hull of p₁, . . . , p_i.

Graham’s Scan: correctness

p_i is added to U X Claim

After each iteration of main loop, U is upper hull of p₁, . . . , p_i. Induction on i. Works for i ≤ 2.

Suppose U is the upper hull of p₁, . . . , p_i−1

p_i U

q

q⁰

p_i−1

⇒ Gray is empty

Graham’s Scan: correctness

p_i is added to U X Claim

After each iteration of main loop, U is upper hull of p₁, . . . , p_i. Induction on i. Works for i ≤ 2.

Suppose U is the upper hull of p₁, . . . , p_i−1

q⁰, p_i−1, p_i ”left turn” ⇔ p_i−1 is below q⁰p_i. Similarly, q⁰ is below qp_i

⇒ All deleted vertices are below the new U.

p_i U

q

q⁰

p_i−1

⇒ Gray is empty

Graham’s Scan: correctness

p_i is added to U X Claim

After each iteration of main loop, U is upper hull of p₁, . . . , p_i. Induction on i. Works for i ≤ 2.

Suppose U is the upper hull of p₁, . . . , p_i−1

q⁰, p_i−1, p_i ”left turn” ⇔ p_i−1 is below q⁰p_i. Similarly, q⁰ is below qp_i

⇒ All deleted vertices are below the new U.

p_i U

q

q⁰

p_i−1

⇒ Gray is empty

⇒ old U and all of p₁, . . . p_i−1 are on or below new U

Graham’s Scan: non-general position

Instead of deleting for left turn in U:

Delete if straight or left turn

• collinear triple:

q q⁰ p_i

Graham’s Scan: non-general position

Instead of deleting for left turn in U:

Delete if straight or left turn

• collinear triple:

q q⁰ p_i

Graham’s Scan: non-general position

Instead of deleting for left turn in U:

Delete if straight or left turn

• collinear triple:

q q⁰ p_i

• equal x-coordiantes:

Graham’s Scan: non-general position

Instead of deleting for left turn in U:

Delete if straight or left turn

• collinear triple:

q q⁰ p_i

• equal x-coordiantes:

Use lexicographic order for initial sort.

(x, y) <_lex (x⁰, y⁰) iff x < x⁰ ∨ (x = x⁰ ∧ y < y⁰)

Graham’s Scan: non-general position

Instead of deleting for left turn in U:

Delete if straight or left turn

• collinear triple:

q q⁰ p_i

• equal x-coordiantes:

Use lexicographic order for initial sort.

(x, y) <_lex (x⁰, y⁰) iff x < x⁰ ∨ (x = x⁰ ∧ y < y⁰)

p₁, p_n are still on the hull.

Upper hull U: part of hull after p₁ and before p_n in cw order

Practicalities

Collinear triples are common (grids!)

Practicalities

Collinear triples are common (grids!)

Almost collinear triples are also common!

Practicalities

Collinear triples are common (grids!)

Almost collinear triples are also common!

P uniform random in [0, 1]²: E( max

p,q,r∈P ^pqr) = π − O(1/n³)

not peer-reviewed source

Practicalities

Collinear triples are common (grids!)

Almost collinear triples are also common!

Naive floating point implementation of Real RAM:

false positives and false negatives

P uniform random in [0, 1]²: E( max

p,q,r∈P ^pqr) = π − O(1/n³)

not peer-reviewed source

Practicalities

Collinear triples are common (grids!)

Almost collinear triples are also common!

Naive floating point implementation of Real RAM:

false positives and false negatives

P uniform random in [0, 1]²: E( max

p,q,r∈P ^pqr) = π − O(1/n³)

Good software libraries (e.g. CGAL) can protect you.

not peer-reviewed source

Chan’s algorithm (1996)

Output-sensitive algorithm

Input size: natural lower bound for most problems

Output size: same! (but useless for decsion problems)

Output-sensitive algorithm

Input size: natural lower bound for most problems

Output size: same! (but useless for decsion problems)

→ An alg. that is faster if the output is small.

→ running time expressed as function of input and output size Output-sensitive algorithm:

Output-sensitive algorithm

Example: enumerating spanning trees of a graph in

O(nⁿ⁻² · n) vs. O(#of trees + n + |E|) time Input size: natural lower bound for most problems

Output size: same! (but useless for decsion problems)

→ An alg. that is faster if the output is small.

→ running time expressed as function of input and output size Output-sensitive algorithm:

Output-sensitive algorithm

Here: h is # of convex hull vertices.

Can we get O(n + h) as running time?

Example: enumerating spanning trees of a graph in

O(nⁿ⁻² · n) vs. O(#of trees + n + |E|) time Input size: natural lower bound for most problems

Output size: same! (but useless for decsion problems)

→ An alg. that is faster if the output is small.

→ running time expressed as function of input and output size Output-sensitive algorithm:

Output-sensitive algorithm

Here: h is # of convex hull vertices.

Can we get O(n + h) as running time?

What about O(n + h log h)?

Example: enumerating spanning trees of a graph in

O(nⁿ⁻² · n) vs. O(#of trees + n + |E|) time Input size: natural lower bound for most problems

Output size: same! (but useless for decsion problems)

→ An alg. that is faster if the output is small.

→ running time expressed as function of input and output size Output-sensitive algorithm:

Output-sensitive convex hull algorithms

• Kirkpatrick–Seidel (’86): O(n log h). Proven optimal!

Output-sensitive convex hull algorithms

• Kirkpatrick–Seidel (’86): O(n log h). Proven optimal!

• Chan (’96): O(n log h), and also ”works” in 3d.

Output-sensitive convex hull algorithms

• Kirkpatrick–Seidel (’86): O(n log h). Proven optimal!

• Chan (’96): O(n log h), and also ”works” in 3d.

Based on the Gift wrapping algorithm:

start from p₁, and go around finding next hull vertex.

• Find p₁: → O(n)

H₁ = p₁

Output-sensitive convex hull algorithms

• Kirkpatrick–Seidel (’86): O(n log h). Proven optimal!

• Chan (’96): O(n log h), and also ”works” in 3d.

Based on the Gift wrapping algorithm:

start from p₁, and go around finding next hull vertex.

• Find p₁: → O(n)

H₁ = p₁

• Given H₁, . . . , H_i, find H_i+1 s.t. ^H_i−1H_iH_i+1 is

maximized → O(n)

H_i H_i−1

Output-sensitive convex hull algorithms

• Kirkpatrick–Seidel (’86): O(n log h). Proven optimal!

• Chan (’96): O(n log h), and also ”works” in 3d.

Based on the Gift wrapping algorithm:

start from p₁, and go around finding next hull vertex.

• Find p₁: → O(n)

H₁ = p₁

• Given H₁, . . . , H_i, find H_i+1 s.t. ^H_i−1H_iH_i+1 is

maximized → O(n)

H_i H_i−1

• Repeated h times

→ O(nh) time in total

Chan’s algorithm

Let m ∈ {1, . . . , n} be a parameter.

Group P into groups of size m

⇒ dn/me groups: P₁, P₂, . . .

Chan’s algorithm

Let m ∈ {1, . . . , n} be a parameter.

Group P into groups of size m

⇒ dn/me groups: P₁, P₂, . . .

Chan’s algorithm

Let m ∈ {1, . . . , n} be a parameter.

Group P into groups of size m

⇒ dn/me groups: P₁, P₂, . . .

Compute convex hull of each P_j with Graham’s scan.

Chan’s algorithm

Let m ∈ {1, . . . , n} be a parameter.

Group P into groups of size m

⇒ dn/me groups: P₁, P₂, . . .

Compute convex hull of each P_j with Graham’s scan.

Chan’s algorithm

Let m ∈ {1, . . . , n} be a parameter.

Group P into groups of size m

⇒ dn/me groups: P₁, P₂, . . .

Compute convex hull of each P_j with Graham’s scan.

Chan’s algorithm

Let m ∈ {1, . . . , n} be a parameter.

Group P into groups of size m

⇒ dn/me groups: P₁, P₂, . . .

Compute convex hull of each P_j with Graham’s scan.

Chan’s algorithm

Let m ∈ {1, . . . , n} be a parameter.

Group P into groups of size m

⇒ dn/me groups: P₁, P₂, . . .

Gift wrapping:

Find largest angle H_i−1H_iq^j with q^j ∈ conv(P_j) for each j, pick best H_i−1

H_i

Compute convex hull of each P_j with Graham’s scan.

Chan’s algorithm

Let m ∈ {1, . . . , n} be a parameter.

Group P into groups of size m

⇒ dn/me groups: P₁, P₂, . . .

Gift wrapping:

Find largest angle H_i−1H_iq^j with q^j ∈ conv(P_j) for each j, pick best H_i−1

H_i

dn/me · O(m log m)

Compute convex hull of each P_j with Graham’s scan.

Chan’s algorithm

Let m ∈ {1, . . . , n} be a parameter.

Group P into groups of size m

⇒ dn/me groups: P₁, P₂, . . .

Gift wrapping:

Find largest angle H_i−1H_iq^j with q^j ∈ conv(P_j) for each j, pick best H_i−1

H_i

dn/me · O(m log m)

hdn/me · O(log m)

Compute convex hull of each P_j with Graham’s scan.

Chan’s algorithm

Let m ∈ {1, . . . , n} be a parameter.

Group P into groups of size m

⇒ dn/me groups: P₁, P₂, . . .

Gift wrapping:

Find largest angle H_i−1H_iq^j with q^j ∈ conv(P_j) for each j, pick best H_i−1

H_i

dn/me · O(m log m)

hdn/me · O(log m)

Time to find tangent of conv(P_j) Compute convex hull of each P_j with Graham’s scan.

Chan’s algorithm: running time and tangent finding

dn/me · O(m log m) + hdn/me · O(log m)

Chan’s algorithm: running time and tangent finding

dn/me · O(m log m) + hdn/me · O(log m)

= O(n log m + (h/m)n log m)

Chan’s algorithm: running time and tangent finding

dn/me · O(m log m) + hdn/me · O(log m)

= O(n log m + (h/m)n log m) setting m = h:

= O(n log h)

Chan’s algorithm: running time and tangent finding

dn/me · O(m log m) + hdn/me · O(log m)

= O(n log m + (h/m)n log m) setting m = h:

= O(n log h) Tangent finding in O(log m) time?

q₁ q₂

q₃ q₄

q₅

q₆

p

1. Set m = h

1. Set m = h

2. Let P_j = {p_(j−1)m+1, . . . , p_jm}.

1. Set m = h

How to set m = h?

?

2. Let P_j = {p_(j−1)m+1, . . . , p_jm}.

1. Set m = h

How to set m = h?

?

2. Let P_j = {p_(j−1)m+1, . . . , p_jm}.

h

X

m=1

cn log m = Ω(hn)...

Idea 1: Let m = 1, 2, . . . , n, run giftwrapping for m steps Stop when gift is wrapped. (Then m ≥ h holds.)

1. Set m = h

How to set m = h?

?

2. Let P_j = {p_(j−1)m+1, . . . , p_jm}.

h

X

m=1

cn log m = Ω(hn)...

Idea 1: Let m = 1, 2, . . . , n, run giftwrapping for m steps Stop when gift is wrapped. (Then m ≥ h holds.)

Too slow!

1. Set m = h

How to set m = h?

?

2. Let P_j = {p_(j−1)m+1, . . . , p_jm}.

h

X

m=1

cn log m = Ω(hn)...

Idea 1: Let m = 1, 2, . . . , n, run giftwrapping for m steps Stop when gift is wrapped. (Then m ≥ h holds.)

Too slow!

dlog he

X

i=1

cn log 2ⁱ =

dlog he

X

i=1

cni = Θ(n log² h)...

Idea 2: Let m = 2¹, 2², 2³, . . . , 2^{log n}, run wrapping for m steps

1. Set m = h

How to set m = h?

?

2. Let P_j = {p_(j−1)m+1, . . . , p_jm}.

h

X

m=1

cn log m = Ω(hn)...

Idea 1: Let m = 1, 2, . . . , n, run giftwrapping for m steps Stop when gift is wrapped. (Then m ≥ h holds.)

Too slow!

dlog he

X

i=1

cn log 2ⁱ =

dlog he

X

i=1

cni = Θ(n log² h)...

Idea 2: Let m = 2¹, 2², 2³, . . . , 2^{log n}, run wrapping for m steps

h

X

m=1

cn log m = Ω(hn)...

Too slow!

1. Set m = h

How to set m = h?

?

2. Let P_j = {p_(j−1)m+1, . . . , p_jm}.

h

X

m=1

cn log m = Ω(hn)...

Idea 1: Let m = 1, 2, . . . , n, run giftwrapping for m steps Stop when gift is wrapped. (Then m ≥ h holds.)

Too slow!

dlog he

X

i=1

cn log 2ⁱ =

dlog he

X

i=1

cni = Θ(n log² h)...

Idea 2: Let m = 2¹, 2², 2³, . . . , 2^{log n}, run wrapping for m steps

h

X

m=1

cn log m = Ω(hn)...

Too slow!

dlog log he

X

i=0

cn log 2²ⁱ =

dlog log he

X

i=0

cn2ⁱ

= cn(2^{dlog log he+1} − 1) = O(n log h) Idea 3: Let m = 2²⁰, 2²¹, 2²², . . . , 2^{2dlog logne}, do m wrap-steps

Chan’s algorithm: Recap

for i = 1 to dlog log ne do m = 2²ⁱ

for j = 1 to dn/me do Create group P_j

(q₁^j, q₂^j, . . . , ) = Graham(P_j) H₁ =leftmost point in P

for s = 2 to m do

for j = 1 to dn/me do

q^j = T angentF ind(H_s−1, (q₁^j, q₂^j, . . . )) H_s = point q^j maximizing ^H_s−2H_s−1q^j if H_s = H₁ then return (H₁, . . . , H_s−1)