【分治】最接近点对Python实现

文章目录

• • @[toc]
  • • 问题描述
    • 一维最接近点对算法
    • • `Python`实现
    • 二维最接近点对算法
    • • 分治算法
      • 时间复杂性
      • `Python`实现

问题描述

• 给定平面上$n$个点，找其中的一对点，使得在$n$个点组成的所有点对中，该点对的距离最小

一维最接近点对算法

Python实现

import sys


def closest_pair(points):
    points.sort()  # 按照横坐标排序
    min_dist = sys.maxsize  # 初始化最小距离为一个很大的数
    closest = None  # 初始化最接近点对为 None

    for i in range(len(points) - 1):
        dist = abs(points[i] - points[i + 1])  # 计算相邻点对的距离

        if dist < min_dist:
            min_dist = dist
            closest = (points[i], points[i + 1])

    return closest


points = [2, 4, 1, 5, 8, 9, 3]

res = closest_pair(points)

print(f'最接近的点对: {res}')

二维最接近点对算法

分治算法

• 选取一垂直线$l:x=m$，$m$为$S$中各点$x$坐标的中位数，将$S$分割为 S 1 = { ? p ∈ S ∣ x ( p ) ≤ m ? } S_{1} = \set{p \in S \mid x(p) \leq m} S1?={p∈S∣x(p)≤m}和 S 2 = { ? p ∈ S ∣ x ( p ) > m ? } S_{2} = \set{p \in S \mid x(p) > m} S2?={p∈S∣x(p)>m}
• 递归地在$S_1$和$S_2$上解最接近点对问题，分别得到$S_1$和$S_2$中的最小距离$d_1$和$d_2$
• 设 d = min ? { ? d 1 , d 2 ? } d = \min\set{d_{1} , d_{2}} d=min{d1?,d2?}，若$S$的最接近点对$(p,q)$之间的距离小于$d$，则$p$和$q$必分属于$S_1$和$S_2$，设$p\in S_1$，$q\in S_2$，则$p$和$q$距直线$l$的距离均小于$d$
• $P_1$和$P_2$分别表示直线$l$的左侧和右侧宽为$d$的两个垂直长条区域，则$p\in P_1$且$q\in P_2$，此时$P_1$中所有点与$P_2$中所有点构成的点对均为最接近点对的候选者，在最坏情况下有$n^2/4$对这样的候选者，但是对于$P_1$中任一点$p$，$P_2$中最多只有$6$个点与它构成最接近点对的候选者
  • 实际上对于$P_1$中任一点$p$，若与$P_2$中的点构成最接近点对的候选者，则必有$distance(p,q)<d$，满足这个条件的$P_2$中的点一定落在一个$d\times 2d$的矩形$R$中
  • 可将矩形$R$的长为$2d$的边$3$等分，将长为$d$的边$2$等分，由此导出$6$个$(d/2)\times (2d/3)$的矩形，矩形$R$中最多只有$6$个$S$中的点

• 合并步骤中，最多只需检查$6\times n/2=3n$个候选者，为了确切地知道要检查哪$6$个点，将$p$和$P_2$中的点投影到垂直线$l$上，能与$p$点一起构成最接近点对候选者的$q$与$p$在$l$上投影点的距离小于$d$，且这种投影点最多只有$6$个，若将$P_1$和$P_2$中所有$S$中点按其$y$坐标排好序，则对$P_1$中所有点，对排好序的点列做一次扫描，就可以找出所有最接近点对的候选者

时间复杂性

$$T(n)=\{\begin{array}{ll}O(1),& n<4\\ 2T(n/2)+O(n),& n\ge 4\end{array}$$

$$T(n)=O(n\log n)$$

Python实现

import math


# 计算两点之间的欧几里德距离
def dist(p1, p2):
    return math.sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2)


# 分治法求解最接近点对问题
def closest_pair(points):
    # 如果点集中的点个数小于等于 3 个, 直接计算并返回最小距离对
    if len(points) <= 3:
        min_dist = float('inf')
        min_pair = None

        for i in range(len(points)):
            for j in range(i + 1, len(points)):
                d = dist(points[i], points[j])

                if d < min_dist:
                    min_dist = d
                    min_pair = (points[i], points[j])

        return min_pair

    # 将点集按照 x 坐标排序
    sorted_points = sorted(points, key=lambda p: p[0])

    # 将点集分成左右两部分
    mid = len(sorted_points) // 2

    left_points = sorted_points[:mid]
    right_points = sorted_points[mid:]

    # 递归求解左右两部分的最接近点对
    left_min_pair = closest_pair(left_points)
    right_min_pair = closest_pair(right_points)

    # 取左右两部分最接近点对的最小距离
    if left_min_pair is None:
        min_dist = dist(right_min_pair[0], right_min_pair[1])
        min_pair = right_min_pair
    elif right_min_pair is None:
        min_dist = dist(left_min_pair[0], left_min_pair[1])
        min_pair = left_min_pair
    else:
        left_dist = dist(left_min_pair[0], left_min_pair[1])
        right_dist = dist(right_min_pair[0], right_min_pair[1])

        if left_dist <= right_dist:
            min_dist = left_dist
            min_pair = left_min_pair
        else:
            min_dist = right_dist
            min_pair = right_min_pair

    # 在横跨左右两部分的点中寻找更近的点对
    mid_x = sorted_points[mid][0]
    strip = []

    # 将点集按照 y 坐标排序
    sorted_points = sorted(points, key=lambda p: p[1])

    for point in sorted_points:
        if abs(point[0] - mid_x) < min_dist:
            strip.append(point)

    for i in range(len(strip)):
        for j in range(i + 1, min(i + 7, len(strip))):
            d = dist(strip[i], strip[j])

            if d < min_dist:
                min_dist = d
                min_pair = (strip[i], strip[j])

    return min_dist, min_pair


points = [(2, 3), (12, 30), (40, 50), (5, 1), (12, 10), (3, 4)]

min_dist, min_pair = closest_pair(points)

print(f'最接近的点对为: {min_pair}, 点对距离为 {min_dist}')