A Simple Yet Fast Algorithm for the Closest-Pair Problem Using Sorted Projections on Multi-dimensions

Transcription

1 A Simple Yet Fast Algorithm for the Closest-Pair Problem Using Sorted Projections on Multi-dimensions Mehmet E. Dalkılıç and Serkan Ergun Abstract We present a simple greedy algorithm, QuickCP, for finding the closestpair of points on a plane. It is based on the observation that if two points are close to each other, then it is very likely that their sorted projections to x-axis and/or to y-axis will reflect that closeness. Therefore we order our search starting from the pairs with closest x-projections (and closest y-projections) to find the closest pair quickly and make a fast exit. Empirical data up to 2 26 (over sixty million points) indicates that this approach quickly detects the closest pair and it is, on average 7 percent faster than the classical divide-and-conquer algorithm registering, to the best of our knowledge, the fastest recorded solution times in the literature for the planar closest-pair problem. A second contribution of our work is that QuickCP can be used as part of the divide-and-conquer algorithms to handle small sub-problems. Measurements on data up to 2 26 points show that this co-operation speeds up the basic divide-andconquer algorithm on average 5 percent. Key words: closest pair problem, greedy algorithm, algorithmic engineering Introduction We address one of the most basic problems in Computational Geometry. Given n points on a plane, find the two points closest to each other. Closest-point problems are fundamental to the Computational Geometry and has applications in graphics, computer vision, geographical information systems, and molecular modeling [6, 8, 9]. Mehmet E. Dalkılıç Serkan Ergun International Computer Institute, Ege University, Izmir, Turkey, {mehmet.emin.dalkilic,serkan.ergun}@ege.edu.tr

2 2 Mehmet E. Dalkılıç and Serkan Ergun It is commonly agreed that the best (most practical) way of solving the above stated two-dimensional closest-pair of points problem is to employ the O(n log n) divide-and-conquer algorithm introduced by Bentley and Shamos []. Although there exist O(n) randomized algorithms [2, 5] for the closest points problem, due to their high implementation complexity, these algorithms are difficult to implement and therefore, the divide and conquer algorithm is often the practical choice for many applications. Using the sorted projections of the input points in x- and y-dimension, a simpler and faster (than the divide and conquer) algorithm can be developed. Even if the algorithm has a worst-case time complexity of O(n 2 ), with a much better average time performance it can be practical and useful. Moreover, any algorithm considerably faster than the divide-and-conquer closest pair (DivConCP) algorithm for the small problem sizes, can be used to speed up the DivConCP algorithm by quickly solving the small sub-problems for it. 2 Proposed Algorithm: QuickCP A typical textbook implementation of the DivConCP algorithm (e.g., [6]) begins with two arrays A and B: in the first array all points are sorted by increasing x- coordinate and in the second array by increasing y-coordinate. Arrays A and B, in fact, contain, respectively, the sorted x-projections and y-projections of the input points. Our observation that these sorted projection arrays can be used in an entirely different fashion than that of the DivConCP algorithm, has led us to the QuickCP algorithm given below. Our main assertion is that if two points are close to each other, then it is very likely that their sorted projections to the x-axis and/or to the y-axis will reflect that closeness. Therefore we can walk through the x-sorted and y-sorted lists in rounds (, 2,..., n ) pairing each point with its r-closest neighbor in both dimensions in the r th round. Empirical data obtained over many runs of the QuickCP algorithm on uniformly distributed random data from 2 4 up to 2 26 (over sixty million) points suggest that QuickCP finds the closest pair and terminates (after guaranteeing that no closer pairs exist) within O(logn) rounds. 2. Algorithm Description QuickCP algorithm is given in Algorithm. It takes a set of two-dimensional points, P, and creates two auxiliary arrays A and B holding the x-sorted and y-sorted points. The algorithm runs in a loop indexed by r. In the first round (r = ), distances for -closest-x pairs and -closest-y pairs are computed recording the minimum distance seen so far. And in the same round, we compute X min which represents the minimum x distance between any -closest-x pairs. Similarly we have Y min representing the minimum y distance between any -closest-y pairs. It is not difficult to

3 A Simple Yet Fast Algorithm for the Closest-Pair Problem 3 Algorithm QuickCP(P) // P = {P,P 2,...,P n } where P i = (x i,y i ) i.e., n input points A sortbyx(p) // Sort P by x-values, store in A i.e., {A(), A(2),..., A(n)} B sortbyy (P) // Sort P by y-values, store in B i.e., {B(), B(2),..., B(n)} d min for r = to n do // at most n rounds X min, Y min for i = to n r do X A(i + r).x A(i).x // A(j).x is the x-value of A(j) Y A(i + r).y A(i).y // A(j).y is the y-value of A(j) X min min( X min, X) // update X min d A X 2 + Y 2 // distance between points A(i) and A(i+r) X B(i + r).x B(i).x // B(j).x is the x-value of B(j) Y B(i + r).y B(i).y // B(j).y is the y-value of B(j) Y min min( Y min, Y ) // update Y min d B X 2 + Y 2 // distance between points B(i) and B(i+r) d min min(d min,d A,d B ) // update d min end for if d min < ( X min ) 2 + ( Y min ) 2 then break // Termination Condition end if end for convince oneself that at this or any later round no two points can be closer to each other than that of ( X min ) 2 + ( Y min ) 2. These minimum distances ( X min, Y min ) together with the closest pair distance so far (d min ) gives us the opportunity to specify the termination condition. At round r each point in the input is first paired with its r-closest-x neighbor and then with its r-closest-y neighbor. If we take the minimum of the X values over all pairs in round r, any pair in any later round will produce X values greater than or equal to that of round r. The same is valid for the Y values. In other words if we define Xmin i as the minimum X value at round i and Y min i as the minimum Y value at round i then X min X 2 min Y min Y 2 min... X n min... Y n min Furthermore, if we have Xmin r and Y min r at round r, in later rounds it is guaranteed that all pairs will produce distances at least as big as ( Xmin r )2 + ( Ymin r )2. In other words, ( Xmin r )2 + ( Ymin r )2 is a lower bound for the distance of any two points. Therefore, we compare the d min at the end of the r th round with this lower bound and if d min ( Xmin r )2 + ( Ymin r )2 then there is no need to look further; the distance of our current closest pair is the final answer. ()

4 4 Mehmet E. Dalkılıç and Serkan Ergun 2.2 Correctness of the Algorithm Case I. Algorithm runs full n rounds. At the r th round for each point A i ( i n r) in the x-sorted list, the algorithm computes distance to its r-closest-x neighbor where r-closest-x neighbor is the point A i+r which is the point r positions left of A i in the x-sorted array. Similarly, at the r th round, the algorithm computes for each point B j ( j n r) in the y-sorted list, the distance to its r-closest-y neighbor where r-closest-y neighbor is the point B i+r which is the point r positions left of B j in the y-sorted array. Therefore if algorithm runs all the rounds, each point will be paired with every other point (in fact twice; once as a i-closest-x neighbor and j-closest-y neighbor where i, j n ). Since the algorithm goes through all possible pairings it will definitely find the closest pair. Since there are n(n )/2 pairs in total, this represents the worst case time complexity of the algorithm which is O(n 2 ). Case II. Algorithm exits at a round r (r < n ). Clearly d min is the minimum distance of any pair explored so far. Is it the minimum distance of any pair not explored yet? The answer is yes because d min computed at the round r satisfies d min ( X r min )2 + ( Y r min )2 and therefore d min is a lower bound on the distance of any pair that would be explored in any round q > r due to (). 2.3 Empirical Average Case Complexity We have implemented our algorithm in C and measured the round number it terminated, under uniformly distributed random inputs of varying size. The results are shown in Fig. where the best fitting curve to this data is c logn + c 2. Since each round s time complexity is O(n), these empirical results suggest that the average case time complexity of the algorithm is O(nlogn). 3 Experiments We compared our algorithm with the closest pair algorithms provided by Jiang and Gillespie [4]. In their paper, they compared different versions of the divide and conquer closest pair algorithm (Basic-7, GWZ-3, Basic-2, 2-pass, Hybrid, Adaptive, Combined). Furthermore, they provided their source code of the test program and the experimental data online at mjiang/ closestpair/. We simply added our algorithm coded in C and run the same test on an Intel Core i7-92, with 2 GB memory and operating system Ubuntu. (64 bit). Test uses randomly generated inputs, sized from 2 4,2 5,...,2 26. For each input size executions (with different random number seeds) are performed. We have selected for comparison with our algorithm QuickCP, Basic-7 (the basic divide-and-conquer algorithm computing seven distances for each point in the

5 A Simple Yet Fast Algorithm for the Closest-Pair Problem round count c log n + c2 Empirical expectation number of points Fig. Expected termination round numbers for different input sizes combine step), GWZ-3 (a divide and conquer algorithm with an optimized combine step, developed by Ge et. al. [3]), Basic-2 (a hybrid of Basic-7 and GWZ-3, independently developed in [4] and [7]), and Combined (an improved version of Basic-2 by two heuristics, presented in [4]). We have not selected algorithm 2-pass because it was the worst of all. Tables and 2 display the total run times for Basic-7, GWZ-3, Basic-2, Combined and our algorithm QuickCP for small (2 4 to 2 4 ) and large (2 5 to 2 26 ) input sizes. Table Total run times (ms) for small input sizes n Basic-7 Basic-2 GWZ-3 Comb. QuickCP Table 2 Total run times (sec) for large input sizes n Basic-7 Basic-2 GWZ-3 Comb. QuickCP Figures 2 and 3 shows, for various inputs sizes, the total run time ratios of GWZ- 3, Basic-2, Combined and QuickCP over Basic-7. QuickCP is the fastest of all. For small (2 4 to 2 4 ) input sizes the run time ratio of QuickCP over Basic-7 is which corresponds to a speed-up of.64. For large (2 5 to 2 26 ) input sizes the run time ratio of QuickCP over Basic-7 is.57 which corresponds to a speed-up of.74. Overall

6 6 Mehmet E. Dalkılıç and Serkan Ergun run time ratio of QuickCP over Basic-7 is.59 which corresponds to a speed-up of.7. In other words, QuickCP is on average 7% faster than Basic-7. The second fastest algorithm is Combined that is on average 3% faster than Basic-7. Basic-2 and GWZ-3, respectively, overall 5% and 3% faster than Basic-7. Combined is the most engineered and optimized algorithm among the suit in [4] and QuickCP is on average 39% faster with a tendency to increase the difference with larger input sizes. Basic 2 GWZ 3 Combined QuickCP Basic 2 GWZ 3 Combined QuickCP Fig. 2 Total run time ratios of Basic-2, GWZ-3, Combined, and QuickCP over Basic-7 for small input sizes Fig. 3 Total run time ratios of Basic-2, GWZ-3, Combined, and QuickCP over Basic-7 for large input sizes All Closest Pair Algorithms spend a large portion of their times on the preprocessing i.e., sorting. Thus, unless a sorting algorithm practically faster than Quick- Sort is found (and takes its place in code libraries), a portion of the run time corresponding to this preprocessing can not be reduced. Therefore, in Figures 4 and 5 we give the run times where preprocessing times excluded. When preprocessing times are excluded, QuickCP is, on average, 6.95 times faster than Basic-7 and the speed-up shows a tendency to increase with larger input sizes. Other three algorithms, Combined, Basic-2 and GWZ-3 line-up with.98,.4 and.32 speed-up over Basic-7, respectively. 4 Improving Divide and Conquer Noting that QuickCP has O(n 2 ) worst-case time complexity, with the guaranteed O(nlogn) time complexity the divide and conquer closest pair algorithms has an advantage. On the other hand, as the experiments show QuickCP is faster. Therefore, we can combine the strong sides of the two, leading to a faster O(nlogn) algorithm. To that extent, we have modified the divide and conquer algorithms (Basic-7, GWZ- 3, Basic-2, and Combined) so that they switch to QuickCP when sub-problems become smaller than a threshold size (determined empirically to be 2 n). We renamed

7 A Simple Yet Fast Algorithm for the Closest-Pair Problem 7 Basic 2 GWZ 3 Combined QuickCP Basic 2 GWZ 3 Combined QuickCP Fig. 4 (Total preprocessing) time ratios of Basic-2, GWZ-3, Combined, and QuickCP over Basic-7 for small input sizes Fig. 5 (Total preprocessing) time ratios of Basic-2, GWZ-3, Combined, and QuickCP over Basic-7 for large input sizes the new versions of the algorithms as Basic-7*, GWZ-3*, Basic-2*, and Combined*. We tested the improved versions on the same data and the same setup of the previous section. Basic 7* Basic 2* GWZ 3* Combined* Basic 7* Basic 2* GWZ 3* Combined* Fig. 6 Total run time ratios of Basic-7*, Basic- 2*, GWZ-3* and Combined* over Basic-7 for small input sizes Fig. 7 Total run time ratios of Basic-7*, Basic- 2*, GWZ-3* and Combined* over Basic-7 for large input sizes Figures 6 and 7 show, for various inputs sizes, the total run time ratios of Basic- 7*, GWZ-3*, Basic-2*, and Combined over Basic-7. Our first observation is that all four algorithms provide a 6% average speed-up over Basic-7 for small input sizes. However, for large input sizes this relative speed-up goes down to 5% for Basic-2* and GWZ-3*; and about 42% for Basic-7* and Combined*. Overall average speed improvements relative to Basic-7 are 55% for Basic-2* and GWZ-3*; and 5% for Basic-7* and Combined*. Compared to the original speed-ups of these algorithms over Basic-7 we see that GWZ-3*, Basic-2* and Combined gained an additional 42%, 4% and 9% speed-up, respectively. For instance while the original imple-

8 8 Mehmet E. Dalkılıç and Serkan Ergun mentation of Basic-2 as given in [4] provides a 5% speed improvement over Basic- 7, our QuickCP boosted version of the same algorithm, Basic-2*, achieves a 55% speed improvement over Basic-7. Basic-7*, QuickCP embedded version of the basic divide and conquer algorithm is 5% faster than its original version, Basic-7. With this newly found partnership, Basic-7* becomes about 2% faster than Combined, the most optimized divide and conquer algorithm in the set. Basic-7* is about 35% faster than other engineered divide and conquer algorithms, Basic-2 and GWZ-3. An interesting observation with improved divide and conquer algorithms (Basic- 7*, Basic-2* and GWZ-3*) is that when the small sub-problems are handled by embedded QuickCP, efficiently, their performances tend to become similar. In other words, performance advantages of optimized algorithms (Basic-2 and GWZ-3) over basic algorithm (Basic-7) diminish, possibly because the improvement obtained by embedding QuickCP in these algorithms, dominates the other optimizations. When we exclude the preprocessing times, results as displayed in Figs. 8 and 9, show that compared to the original speed-ups of these algorithms over Basic-7 we see that Basic-7*, GWZ-3*, Basic-2* and Combined* gained an additional 22%, 26%, 25% and 4% speed-up, respectively. Basic 7* Basic 2* GWZ 3* Combined* Basic 7* Basic 2* GWZ 3* Combined* Fig. 8 (Total preprocessing) time ratios of Basic-7*, Basic-2*, GWZ-3*, and Combined* over Basic-7 for small input sizes Fig. 9 (Total preprocessing) time ratios of Basic-7*, Basic-2*, GWZ-3*, and Combined* over Basic-7 for large input sizes Even though the impact of this high speed-up improvements on the total run times are relatively less e.g., 4% for Basic-2*, this represent a significant improvement on an already engineered and fine-tuned divide and conquer algorithm. As a final note, the run time values given in [4] excludes the preprocessing times and the best improvement ratio they obtain is.558 which corresponds to 79% speed improvement which is achieved via the Combined algorithm. In this paper by embedding the QuickCP we have obtained a better version of the Combined (labeled Combined*) with an additional speed improvement of 4% when preprocessing times are excluded. Furthermore, this 4% speed-up is a relatively low improvement rate compared to the average improvement rate of about 25% that we have achieved for the other three divide and conquer algorithms.

9 A Simple Yet Fast Algorithm for the Closest-Pair Problem 9 5 Conclusion We have presented a new and practical algorithm, QuickCP, for closest-pair problem. QuickCP is both simpler and faster than the divide-and-conquer algorithms for computing the closest pair of points. We have implemented and tested QuickCP for random inputs up to sixty million points and on average it is 7% faster than the classical divide and conquer while about 4% faster than the most optimized divided and conquer algorithm (called Combined in the paper). Furthermore, when we exclude the preprocessing times QuickCP s speed advantage gets much bigger. Another contribution of QuickCP is that it can be embedded in the divide and conquer algorithms to quickly handle small cases. We have pursued this option and observed that even the classic divide and conquer closest pair algorithm (called Basic-7 in the paper) becomes faster than the most optimized divide and conquer algorithm. QuickCP algorithm described in two-dimensions in this paper, can easily be extended to three and upper dimensions. Also we are planning to adapt our approach to other problems in Computational Geometry and Graphics. Acknowledgements We sincerely thank Minghui Jiang and Joel Gillespie for their generosity of sharing their source code and experiment data. We are planning to do the same after publishing our research. References. Bentley, J.L., Shamos, M.I.: Divide-and-conquer in multidimensional space. In: Proceedings of the eighth annual ACM symposium on Theory of computing, STOC 76, pp ACM, New York, NY, USA (976) 2. Dietzfelbinger, M., Hagerup, T., Katajainen, J., Penttonen, M.: A reliable randomized algorithm for the closest-pair problem. J. Algorithms 25(), 9 5 (997) 3. Ge, Q., Wang, H.T., Zhu, H.: An improved algorithm for finding the closest pair of points. Journal of Computer Science and Technology 2, 27 3 (26)..7/s Jiang, M., Gillespie, J.: Engineering the divide-and-conquer closest pair algorithm. J. Comput. Sci. Technol. 22(4), (27) 5. Khuller, S., Matias, Y.: A simple randomized sieve algorithm for the closest-pair problem. Information and Computation 8(), (995) 6. Kleinberg, J., Tardos, E.: Algorithm Design. Addison-Wesley (26) 7. Pereira, J.C., Lobo, F.G.: An optimized divide-and-conquer algorithm for the closest-pair problem in the planar case. Journal of Computer Science and Technology 27(4), (22) 8. Preparata, F.P., Shamos, M.I.: Computational geometry: an introduction. Springer-Verlag New York, Inc., New York, NY, USA (985) 9. Smid, M.: Closest-point problems in computational geometry. Handbook of Computational Geometry pp (997)