Closest Pair of points algorithm

Author: AhmedNader42

Closest Pair/ClosestPair.playground/Contents.swift

@@ -0,0 +1,224 @@
+//Created by Ahmed Nader (github: AhmedNader42) on 4/4/18.
+
+func ClosestPairOf(points: [Point]) -> (minimum:Double, firstPoint:Point, secondPoint:Point) {
+    var innerPoints = mergeSort(points, sortAccording : true)
+    let result = ClosestPair(&innerPoints, innerPoints.count)
+    return (result.minValue, result.firstPoint, result.secondPoint)
+}
+
+func ClosestPair(_ p : inout [Point],_ n : Int) -> (minValue: Double,firstPoint: Point,secondPoint: Point)
+{
+    // Brute force if only 3 points (To end recursion)
+    if n <= 3
+    {
+        var i=0, j = i+1
+        var minDist = Double.infinity
+        var newFirst:Point? = nil
+        var newSecond:Point? = nil
+        while i<n
+        {
+            j = i+1
+            while j < n
+            {
+                if dist(p[i], p[j]) <= minDist
+                {
+                    minDist = dist(p[i], p[j])
+                    newFirst = p[i]
+                    newSecond = p[j]
+                }
+                j+=1
+            }
+            i+=1
+            
+        }
+        return (minDist, newFirst ?? Point(0,0), newSecond ?? Point(0,0))
+    }
+    
+    
+    
+    let mid:Int = n/2
+    let line:Double = (p[mid].x + p[mid+1].x)/2
+    
+    // Split the array.
+    var leftSide = [Point]()
+    var rightSide = [Point]()
+    for s in 0..<mid
+    {
+        leftSide.append(p[s])
+    }
+    for s in mid..<p.count
+    {
+        rightSide.append(p[s])
+    }
+    
+    
+    // Recurse on the left and right part of the array.
+    let valueFromLeft = ClosestPair(&leftSide, mid)
+    let minLeft:Double = valueFromLeft.minValue
+    let valueFromRight = ClosestPair(&rightSide, n-mid)
+    let minRight:Double = valueFromRight.minValue
+    
+    // Starting current min must be the largest possible to not affect the real calculations.
+    var min = Double.infinity
+    
+    var first:Point
+    var second:Point
+    
+    // Get the minimum between the left and the right.
+    if minLeft < minRight {
+        min = minLeft
+        first = valueFromLeft.firstPoint
+        second = valueFromLeft.secondPoint
+    }
+    else {
+        min = minRight
+        first = valueFromRight.firstPoint
+        second = valueFromRight.secondPoint
+    }
+    
+    // Sort the array according to Y.
+    p = mergeSort(p, sortAccording: false)
+    
+    
+    var strip = [Point]()
+    
+    // If the value is less than the min distance away in X from the line then take it into consideration.
+    var i=0, j = 0
+    while i<n
+    {
+        if abs(p[i].x - line) < min
+        {
+            strip.append(p[i])
+            j+=1
+        }
+        i+=1
+    }
+    
+    
+    i=0
+    var x = i+1
+    var temp = min
+    var tempFirst:Point = Point(0,0)
+    var tempSecond:Point = Point(0,0)
+    // Get the values between the points in the strip but only if it is less min dist in Y.
+    while i<j
+    {
+        x = i+1
+        while x < j
+        {
+            if (abs(strip[x].y - strip[i].y)) > min { break }
+            if dist(strip[i], strip[x]) < temp
+            {
+                temp = dist(strip[i], strip[x])
+                tempFirst = strip[i]
+                tempSecond = strip[x]
+            }
+            x+=1
+        }
+        i+=1
+    }
+    
+    if temp < min
+    {
+        min = temp;
+        first = tempFirst
+        second = tempSecond
+    }
+    return (min, first, second)
+}
+
+
+
+
+// MergeSort the array (Taken from Swift Algorithms Club with
+// minor addition)
+// sortAccodrding : true -> x, false -> y.
+func mergeSort(_ array: [Point], sortAccording : Bool) -> [Point] {
+    guard array.count > 1 else { return array }
+    let middleIndex = array.count / 2
+    let leftArray = mergeSort(Array(array[0..<middleIndex]), sortAccording: sortAccording)
+    let rightArray = mergeSort(Array(array[middleIndex..<array.count]), sortAccording: sortAccording)
+    return merge(leftPile: leftArray, rightPile: rightArray, sortAccording: sortAccording)
+}
+
+
+private func merge(leftPile: [Point], rightPile: [Point], sortAccording: Bool) -> [Point] {
+    
+    var compare : (Point, Point) -> Bool
+    
+    // Choose to compare with X or Y.
+    if sortAccording
+    {
+        compare = { p1,p2 in
+            return p1.x < p2.x
+        }
+    }
+    else
+    {
+        compare = { p1, p2 in
+            return p1.y < p2.y
+        }
+    }
+    
+    var leftIndex = 0
+    var rightIndex = 0
+    var orderedPile = [Point]()
+    if orderedPile.capacity < leftPile.count + rightPile.count {
+        orderedPile.reserveCapacity(leftPile.count + rightPile.count)
+    }
+    
+    while true {
+        guard leftIndex < leftPile.endIndex else {
+            orderedPile.append(contentsOf: rightPile[rightIndex..<rightPile.endIndex])
+            break
+        }
+        guard rightIndex < rightPile.endIndex else {
+            orderedPile.append(contentsOf: leftPile[leftIndex..<leftPile.endIndex])
+            break
+        }
+        
+        if compare(leftPile[leftIndex], rightPile[rightIndex]) {
+            orderedPile.append(leftPile[leftIndex])
+            leftIndex += 1
+        } else {
+            orderedPile.append(rightPile[rightIndex])
+            rightIndex += 1
+        }
+    }
+    return orderedPile
+}
+
+
+// Structure to represent a point.
+struct Point
+{
+    var x: Double
+    var y: Double
+    
+    init(_ x:Double,_ y:Double) {
+        self.x = x
+        self.y = y
+    }
+}
+// Get the distance between two points a, b.
+func dist(_ a: Point,_ b: Point) -> Double
+{
+    let equation:Double = (((a.x-b.x)*(a.x-b.x))) + (((a.y-b.y)*(a.y-b.y)))
+    return equation.squareRoot()
+}
+
+
+var a = Point(0,2)
+var b = Point(6,67)
+var c = Point(43,71)
+var d = Point(1000,1000)
+var e = Point(39,107)
+var f = Point(2000,2000)
+var g = Point(3000,3000)
+var h = Point(4000,4000)
+
+
+var points = [a,b,c,d,e,f,g,h]
+let endResult = ClosestPairOf(points: points)
+print("Minimum Distance : \(endResult.minimum), The two points : (\(endResult.firstPoint.x ),\(endResult.firstPoint.y)), (\(endResult.secondPoint.x),\(endResult.secondPoint.y))")
+

Closest Pair/ClosestPair.playground/contents.xcplayground

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<playground version='5.0' target-platform='macos' executeOnSourceChanges='false'>
+    <timeline fileName='timeline.xctimeline'/>
+</playground>

Closest Pair/ClosestPair.playground/playground.xcworkspace/contents.xcworkspacedata

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>IDEDidComputeMac32BitWarning</key>
+	<true/>
+</dict>
+</plist>

Closest Pair/ClosestPair.playground/playground.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist

@@ -0,0 +1,88 @@
+# ClosestPair
+
+Closest Pair is an algorithm that finds the closest pair of a given array of points By utilizing the Divide and Conquer methodology of solving problems so that it reaches the correct solution with O(nlogn) complexity.
+
+![Given points and we're required to find the two red ones](../Closest Pair/Images/1200px-Closest_pair_of_points.png)
+
+As we see in the above image there are an array of points and we need to find the closest two, But how do we do that without having to compare each two points which results in a whopping O(n^2) complexity?
+
+Here is the main algorithm (Steps) we'll follow.
+
+- Sort the array according to their position on the X-axis so that they are sorted in the array as they are naturally in math.
+
+```swift
+var innerPoints = mergeSort(points, sortAccording : true)
+```
+
+- Divide the points into two arrays Left, Right and keep dividing until you reach to only having 3 points in your array.
+
+- The base case is you have less than 3 points compare those against each other (Brute force) then return the minimum distance you found and the two points.
+
+- Now we get the first observation in the below image, There could be 2 points both very close to each other and indeed those two are the closest pair but since our algorithm so far divides from the middle
+ 
+```swift
+let line:Double = (p[mid].x + p[mid+1].x)/2
+```
+
+and just recursively calls itself until it reaches the base case we don't detect those points.
+
+![ Points lying near the division line](../Closest Pair/Images/Case.png)
+
+- To solve this we start by sorting the array on the Y-axis to get the points in their natural order and then we start getting the difference between the X position of the point and the line we drew to divide and if it is less than the min we got so far from the recursion we add it to the strip 
+
+```swift
+var strip = [Point]()   
+var i=0, j = 0
+while i<n
+{
+	if abs(p[i].x - line) < min
+	{
+		strip.append(p[i])
+		j+=1
+	}
+	i+=1
+}
+```
+
+- After you insert the points that could possibly give you a better min distance we get to another observation in the image below.
+
+![The strip with 4 points shown](..//Closest Pair/Images/Strip.png)
+
+- Searching the strip is a brute force loop (But doesn't that just destroy everything we did? You ask) but it has an advantage it could never iterate on more than 8 points (worst case).
+
+- The reason is that the strip is constructed as a rectangle with sides of length = min that we got from the recursion and we ignore any points that have a Y difference bigger than min distance so to be able to place them ALL inside the rectangle with these conditions they'll have to be in the shape above with each one of them EXACTLY min distance away from the other which gives us 4 possible points for each one and 8 in total.
+
+```swift
+while i<j
+    {
+        x = i+1
+        while x < j
+        {
+            if (abs(strip[x].y - strip[i].y)) > min { break }
+            if dist(strip[i], strip[x]) < temp
+            {
+                temp = dist(strip[i], strip[x])
+                tempFirst = strip[i]
+                tempSecond = strip[x]
+            }
+            x+=1
+        }
+        i+=1
+    }
+```
+
+- Of course not every time you end up with the same shape but this is the worst case and it's rare to happen so in reality you end up with far less points valid for comparison and this is why the algorithm gets performance in addition to the sorting tricks we did.
+
+- Compare the points in the strip and if you find a smaller distance replace the current one with it.
+
+
+So this is the rundown of how the algorithm works and you could see the fun little math tricks used to optimize this and we end up with O(nlogn) complexity mainly because of the sorting.
+
+
+## See also
+
+See the playground to play around with the implementation of the algorithm
+
+[Wikipedia](https://en.wikipedia.org/wiki/Closest_pair_of_points_problem)
+
+*Written for Swift Algorithm Club by [Ahmed Nader](https://github.com/ahmednader42)*