algorithm-in-python/divideAndConquer/min_distance_of_n_points.py

''' mbinary
#########################################################################
# File : min_distance_of_n_points.py
# Author: mbinary
# Mail: zhuheqin1@gmail.com
# Blog: https://mbinary.xyz
# Github: https://github.com/mbinary
# Created Time: 2018-11-24  22:03
# Description:
#########################################################################
'''
from random import randint
from time import time
from functools import total_ordering


@total_ordering
class point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __neg__(self):
        return pont(-self.x, -self.y)

    def __len__(self):
        return self.norm(2)

    def __lt__(self, p):
        return self.x < p.x or (self.x == p.x and self.y < p.y)

    def __eq__(self, p):
        return self.x == p.x and self.y == p.y

    def __hash__(self):
        return hash((self.x, self.y))

    def __repr__(self):
        return 'point({},{})'.format(self.x, self.y)

    def __str__(self):
        return self.__repr__()

    def norm(self, n=2):
        if n <= 0:
            return max(abs(self.x), abs(self.y))
        return (abs(self.x)**n+abs(self.y)**n)**(1/n)

    def distance(self, p):
        return ((self.x-p.x)**2+(self.y-p.y)**2)**0.5


def minDistance_n2(points):
    n = len(points)
    if n <= 1:
        return 0
    p, q = points[:2]
    minD = points[0].distance(points[1])
    for i in range(n-1):
        for j in range(i+1, n):
            d = points[i].distance(points[j])
            if d < minD:
                minD = d
                p = points[i]
                q = points[j]
    return minD, p, q


def findif(points, f, reverse=False):
    n = len(points)
    rg = range(n-1, -1, -1) if reverse else range(n)
    for i in rg:
        if not f(points[i]):
            return points[i+1:] if reverse else points[:i]
    return points.copy()  # note that don't return exactly points, return a copy one


def floatEql(f1, f2, epsilon=1e-6):
    return abs(f1-f2) < epsilon


def minDistance_nlogn(n_points):
    def _min(pts):
        n = len(pts)
        if n == 2:
            return pts[0].distance(pts[1]), pts[0], pts[1]
        if n == 3:
            minD = pts[0].distance(pts[1])
            p, q = pts[0], pts[1]
            d2 = pts[2].distance(pts[1])
            if minD > d2:
                minD = d2
                p, q = pts[1], pts[2]
            d2 = pts[0].distance(pts[2])
            if minD > d2:
                return d2, pts[0], pts[2]
            else:
                return minD, p, q
        n2 = n//2
        mid = (pts[n2].x + pts[n2-1].x)/2
        s1 = pts[:n2]
        s2 = pts[n2:]
        minD, p, q = _min(s1)
        d2, p2, q2 = _min(s2)
        # print('\n\n',minD,p,q,s1)
        # print(d2,p2,q2,s2)
        if minD > d2:
            minD, p, q = d2, p2, q2

        linePoints = findif(s1, lambda pt: floatEql(pt.x, mid), reverse=True)
        linePoints += findif(s2, lambda pt: floatEql(pt.x, mid))
        n = len(linePoints)
        if n > 1:
            for i in range(1, n):
                dis = linePoints[i].y - linePoints[i-1].y
                if dis < minD:
                    minD = dis
                    p, q = linePoints[i-1], linePoints[i]
        leftPoints = findif(s1, lambda pt: pt.x >= mid-minD, reverse=True)
        rightPoints = findif(s2, lambda pt: pt.x <= mid+minD)
        for lp in leftPoints:
            y1, y2 = lp.y-minD, lp.y+minD
            for rp in rightPoints:
                if y1 < rp.y < y2:
                    dis = lp.distance(rp)
                    if dis < minD:
                        minD = dis
                        p, q = lp, rp
        return minD, p, q
    return _min(sorted(n_points))


def test(f=minDistance_n2):
    print('\ntest  : ', f.__name__)
    begin = time()
    minD, p, q = f(points)
    print('time  : {:.6f} s'.format(time()-begin))
    print('result: {:.2f} {} {}\n'.format(minD, p, q))


def genData(n, unique=True):
    upper = 1000000
    if unique:
        points = set()
        for i in range(n):
            points.add(point(randint(1, upper), randint(1, upper)))
        return list(points)
    else:
        return [point(randint(1, upper), randint(1, upper)) for i in range(n)]


if __name__ == '__main__':
    n = 1000
    points = genData(n, unique=True)
    print('min distance of {} points'.format(n))
    # print(sorted(points))
    test(minDistance_n2)
    test(minDistance_nlogn)