Given a list of n  8 integers, what is the runtime bound on the optimal algorithm that sorts the first eight? O(1) O(log n) O(n) O(n log n) O(n2)

Given a list of n  8 integers, what is the runtime bound on the optimal algorithm that sorts the first eight? O(1) O(log n) O(n) O(n log n) O(n2)

Closest Point Problem

Problem Statement Input: A set of points on the plane (given in the form of x and y coordinates) Output: One pair of the input points Goal: Return the closest pair

Example

What is the runtime for the naive Closest Point algorithm? O(log n) O(n) O(n log n) O(n2) O(n3)

What is the runtime for the naive Closest Point algorithm? O(log n) O(n) O(n log n) O(n2) O(n3)

Divide and Conquer: Attempt 1 Step 1: Split list in two based on median x value Step 2: Recursively apply algorithm to each half Step 3: Return the closer of the two pairs

Sample Execution

The algorithm always returns the optimal answer. True False

The algorithm always returns the optimal answer. True False

Sample Execution (Counter Example)

Divide and Conquer: Attempt 2 Step 1: Split in two based on median x value Step 2: Recursively apply algorithm to each half Step 3: Check every node on the left against every node on the right

What is the runtime of this formula? T(n) = 2T(n/2) + (n) T(n) = 2T(n/2) + (n2) T(n) = T(n/2) + (n) T(n) = T(n/2) + (n2)

What is the runtime of this formula? T(n) = 2T(n/2) + (n) T(n) = 2T(n/2) + (n2) T(n) = T(n/2) + (n) T(n) = T(n/2) + (n2)

Analysis T(n) = 2T(n/2) + (n2 ) a = 2, b = 2, logba = 1 f(n) = (n2) f(n) = (n1+ ) (and regularity holds) If we want T(n) = (n log n), we can only spend linear time in the split/merge  T(n) = (n2)

  L R  = min(L, R )

Divide and Conquer: Attempt 3 Step 1: Split in two based on median x value Step 2: Recursively apply algorithm to each partition Let L and R be the minimum distance on each side Let  = min(L, R) Step 3: Check only points within  of the dividing line against each other

Worst Case 2 Still requires O(n2 ) time 

Don’t need to look more than  below this point We only need to compare this point against those in the rectangle  L How many points can be in the rectangle? R  = min(L, R )

Point Limit Limit: 8 points in the rectangle    Region now blocked out – no points can fall in the blue   2  2 Could have two points here (one per partition) Assume this is in the left partition

Checking Points To process the “strip”: Sort the points by y coordinate For each point: If this point is the upper left-hand (or right-hand) corner of a box, the box can only contain seven more points Those points would have to be the next seven in the sorted order We need only compare this point against the next seven in the list (O(1) time)

Algorithm Sort points by x coordinate ((n log n)) Calculate partition point ((1)) Recursively find L, R and  ( 2T(n/2)) Remove elements outside of “strip” ((n)) Sort by y coordinate ((n log n)) For each point in strip: Check against the next seven points ((1)) T(n) = 2T(n/2) + (n log n)

Analysis T(n) = 2T(n/2) + (n log n) Master Theorem won’t work – this is the “gap” between case two and three Turns out: T(n) = (n log n) – not what we wanted We can speed this up pre-processing

Pre-processing Pre-processing: “Setup work” done before calling the algorithm In this case, before starting the algorithm: Sort all points by x coordinate Sort all points by y coordinates (Actually, sort a list of references into the point list – this gets tricky) If you maintain your data correctly, you will not need to sort again

Algorithm Sort points by x coordinate ((n log n)) Calculate partition point ((1)) Recursively find L, R and  (2T(n/2)) Remove elements outside of “strip” ((n)) Sort by y coordinate ((n log n)) For each point in strip: Check against the next seven points ((1)) T(n) = 2T(n/2) + (n log n) (n )

Analysis T(n) = 2T(n/2) + (n)

What is the runtime of this algorithm (not counting pre-processing) O(log n) O(n) O(n log n) O(n2)

What is the runtime of this algorithm (not counting pre-processing) O(log n) O(n) O(n log n) O(n2)

T(n) = 2T(n/2) + (n) Same as merge sort, so: T(n) = (n log n) Analysis T(n) = 2T(n/2) + (n) Same as merge sort, so: T(n) = (n log n) With preprocessing: n log n + T(n) – still (n log n)