13.4. Two Dimensional Case

We now look at another divide and conquer algorithm, this is the geometric problem, given a set of points we would like to compute the closest pair of points among them.

This chunk introduces a geometric problem where the goal is to find the closest pair of points among a given set of points. The problem is approached using a divide and conquer algorithm, which allows for more efficiency compared to direct computations.

Imagine you are a park ranger trying to find the two trees closest to each other in a large forest. Instead of measuring the distance between every pair of trees (which would take a long time), you could divide the forest into sections, measure the distances in each section, and then only measure the distances between the closest trees across the sections.

So, recall that at the beginning of this set of lectures to motivate the need for more efficient algorithms, you consider the example of the video game, if there are several objects on the screen and you might want to find it at any given point, the closest pair of objects among them. So, for this again a naive algorithm could be to explicitly compute the distance between every pair of these n objects, which should be an order n squared algorithm.

The naive or brute force approach requires calculating the distance between each pair of points, leading to a time complexity of O(n^2). However, through divide and conquer, we can reduce the complexity to O(n log n), which is significantly faster for large datasets.

Think of a library with thousands of books. If you were to find the two books closest in size, checking each pair of books would take a long time. Instead, organizing the books by sizes and narrowing down the search using that organization saves time.

So, formally we are looking at points in two dimensions, so each point is given by an x, y coordinate x p, y p and we are using the usual utility and motion of distance that is the distance given by Pythagoras formula, which is that the distance between p 1 and p 2 is the square root of (x2 - x1)² + (y2 - y1)².

In two-dimensional space, each point has coordinates represented as (x, y). The distance between two points can be calculated using the Pythagorean theorem. This theorem helps in understanding how far apart two points are in a plane, which is essential for finding the closest pair.

Imagine a flat map of a city. Each location can be identified by coordinates, like intersections on the map. The distance formula helps you understand how far apart these two places are, which can help in planning efficient routes.

Now, it will be convenient for the analysis of the algorithm that we are going to suggest that no two points in this set have the same x or y coordinate.

To simplify the analysis of the algorithm, it's assumed that every point has a unique x and y coordinate. This means no two points share the same position, which allows the algorithm to avoid complications that arise from handling duplicates.

Think of a classroom of students where each student has a unique ID number. This uniqueness simplifies the process of finding and referencing each student, just like having unique coordinates simplifies finding the closest pair of points.

In two dimensions, if we are going to use divide and conquer, we need a way of separating the points into two groups, a roughly equal size or a hopefully exactly equal size.

The essence of the divide and conquer strategy is to split the set of points into two groups using a vertical line. This simplifies the problem into smaller subsets, which can be solved individually. Each subset finishes by finding the closest pair, while the main challenge is also to consider points across the dividing line.

Imagine sorting a deck of cards. Instead of sorting all the cards at once, you divide the deck into two halves. You sort each half and then combine them back together. This method is efficient and reduces the overall effort required to sort the whole deck.

Because of we divide and conquer thing what we will do is, we will compute the smallest distance among the points to the left, separately we will compute the smallest distance points from the right.

Once we've computed the smallest distances in the left and right groups independently, we still have the possibility of closer pairs crossing the boundary. We need to check pairs that might straddle the line separating the two groups, which could potentially have a smaller distance.

If you have two separate teams in a relay race, you not only need to measure the fastest members of each team but also see who can sprint the fastest when switching off the baton at the junction where the teams meet.

So, we will compute points, the set of points we will compute two sorted orders. So, we will first scan these points by x coordinate from left to right and we will listed in this order and call it P x, then we will scan this, the list P from...

The algorithm requires two sorted lists of the points: one sorted by x-coordinates and the other by y-coordinates. This is achieved by scanning through the list and creating these sorted arrays, which is crucial for the next steps in the divide and conquer process.

Think of organizing your bookshelf. You first sort the books by title (first list), and then you create another list by author (second list). Having these sorts allows you to quickly locate the books later.

So, we assume that we have done to this, of course, we can do this we know in order n log n time right to the beginning. Now, the next step is to do this recursive call and so when we do the recursive call, because we have P x sort it by x coordinate, we know that the line that we need to draw is the one that separates P x into two equal parts.

After sorting the points, the algorithm makes recursive calls to find the closest pairs in each of the two halves. Each recursive call further divides the problem until there are enough points to simply calculate the distance between them through brute force.

Imagine if you keep breaking a large problem into smaller pieces until each piece is simple enough to solve independently. Once you've conquered the smaller problems, you can then combine those solutions back into your original problem.

--