【分治法】最接近点对问题 C++（附代码分析及实例）

已于 2025-04-22 22:00:34 修改
阅读量1.2k 收藏 27
点赞数 46
分类专栏： 算法设计与分析 文章标签： 算法 c++ 分治
于 2025-03-19 21:40:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lhr056813/article/details/146379344
版权

问题描述

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

问题分析

先考虑一下一维情况下，取中间某个点m，将所有点划分为两个集合，递归的找出左右集合的最接近点对，最后再和最靠近点m的左右两点间的距离作比较，最小的就是整个点对中最接近的

现在将一维的情况扩展到二维，二维比一维复杂的地方在于每个点都有两个坐标，我们用一条直线l将平面上的所有点同样分成两个集合，再递归的去两个集合中找最接近的点对，可以得到左右两个最近距离，取它们俩较小的值作为d，用于后面的寻找。

直线l如何确定呢，我们选择所有点的x坐标的中位数作为l的x坐标，这样可以将大问题分成左右两个规模大致相同的子问题

找到左右两个子集的最接近距离后，再找跨区域的点对。乍一看，似乎每个点都要和对面的每一个点进行一次计算，但实际上，我们只需要考虑距离直线l小于d的点，大于d的点和对面区域的距离显然大于d。

在这里插入图片描述

  • 考虑S1中任意一点p，它如果有可能与S2中的点q构成最接近点对，则必有distance(p，q)<d。满足这个条件的S2中的点一定落在一个d×2d的矩形R中
  • 由d的意义可知，S2中任何两个S中的点的距离都不可能小于d
  • 因此，在分治法的合并步骤中，最多只需要检查6xn/2=3n个候选者

证明为什么每个点只需要检查6个点
将矩形R的长为2d的边三等分，将它的长为d的边2等分，由此导出6个(d/2)x(2d/3)的矩形。若矩形R中有2个以上S中的点。设u、v是位于同一小矩形中的两个点，则distance(u,v)<d，这与d的意义相矛盾

在这里插入图片描述
为了确切的知道是哪6个点，可以将p和S2中所有的点投影到直线l上。由于能与p点一起构成最接近点对的点一定在矩阵R中，所以它们在直线l上的投影点距p的投影点的距离小于d。

因此，若将S1和S2中所有点按其y坐标排好序，则对S1中的所有点，对排好序的点列做一次扫描，就可以找出所有可能构成最接近点对的点

代码

数据结构

实现了两个类PointX和PointY，存储点的x、y坐标，PointY类额外使用成员变量p来对应该点在X中的下标。重载了<=运算符，用于按x和按y排序

class PointX {
public:
	int operator<=(const PointX a) const {
		return x <= a.x;
	}
public:
	float x, y;
};
class PointY {
public:
	int operator<=(const PointY a) const {
		return y <= a.y;
	}
public:
	int p;
	float x, y;
};

Cpair函数

main函数直接调用，进行预处理（排序、设置p的对应关系）后调用closest函数进行计算

bool Cpair(PointX X[], int n, PointX& a, PointX& b, float &d) {
	if (n < 2) {
		return false;//没有点对
	}
	MergeSort(X, n);//按x排序
	PointY* Y = new PointY[n];
	for (int i = 0; i < n; i++)
	{
		Y[i].p = i;//记录Y中每个点的原始位置
		Y[i].x = X[i].x;
		Y[i].y = X[i].y;
	}
	MergeSort(Y, n);//按y排序
	PointY* Z = new PointY[n];
	closest(X, Y, Z, 0, n - 1, a, b, d);
	delete[] Y;
	delete[] Z;
	return true;
}

closest函数

void closest(PointX X[], PointY Y[], PointY Z[], int l, int r, PointX& a, PointX& b, float& d) {
	if (r - l == 1) {
		a = X[l];
		b = X[r];
		d = distance(X[l], X[r]);
		return;
	}
	if (r - l == 2) {
		float d1 = distance(X[l], X[l + 1]);
		float d2 = distance(X[l+1], X[r]);
		float d3 = distance(X[l], X[r]);
		if (d1 <= d2 && d1 <= d3) {
			a = X[l];
			b = X[l + 1];
			d = d1;
			return;
		}
		if (d2 <= d3) {
			a = X[l];
			b = X[r];
			d = d2;
		}
		else {
			a = X[l];
			b = X[r];
			d = d3;
		}
		return;
	}
	//多于三个点，分治法
	int m = (l + r) / 2;
	int f = l, g = m + 1;
	for (int i = l; i <= r; i++) {
		if (Y[i].p > m)
			Z[g++] = Y[i];
		else
			Z[f++] = Y[i];
	}
	closest(X, Z, Y, l, m, a, b, d);
	float dr;
	PointX ar, br;
	closest(X, Z, Y, m + 1, r, ar, br, dr);
	if (dr < d) {
		a = ar;
		b = br;
		d = dr;
	}
	//重构数组Y
	Merge(Z, Y, l, r);//把Z合并到Y中
	int k = l;
	for (int i = l; i <= r; i++) {
		if (fabs(X[m].x - Y[i].x) < d)
			Z[k++] = Y[i];
	}
	for (int i = l; i < k; i++) {
		for (int j = i + 1; j < k && Z[j].y - Z[i].y < d; j++) {
			float dp = distance(Z[i], Z[j]);
			if (dp < d) {
				d = dp;
				a = X[Z[i].p];
				b = X[Z[j].p];
			}
		}
	}
}

在这个函数中，首先判断点对的个数，三个及以内就直接计算两两之间的距离，取最小即可。

如果点数大于三，就用分治法，先确定直线l的索引m，再递归的求左右两个区间的最短距离，选最小的作为d

int k = l;
for (int i = l; i <= r; i++) {
    if (fabs(X[m].x - Y[i].x) < d)
        Z[k++] = Y[i];
}

这一步选出位于分割线（中线）附近、可能形成更近点对的候选点，将这些候选点存储在Z中。X[m].x就是中位线的横坐标

for (int i = l; i < k; i++) { 
    for (int j = i + 1; j < k && Z[j].y - Z[i].y < d; j++) {
        float dp = distance(Z[i], Z[j]);
        if (dp < d) {
            d = dp;
            a = X[Z[i].p];
            b = X[Z[j].p];
        }
    }
}

​上面这一步用于在候选点中寻找距离更近的点对。

​外层循环：遍历每个候选点Z[i]。
​内层循环：对每个Z[i]，仅检查其后满足y坐标差小于d的点Z[j]。
若找到比当前d更小的距离dp，更新最小距离和对应点对。

这样最终的d值就是最接近点对的距离

完整实例

#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
class PointX {
public:
	int operator<=(const PointX a) const {
		return x <= a.x;
	}
public:
	float x, y;
};
class PointY {
public:
	int operator<=(const PointY a) const {
		return y <= a.y;
	}
public:
	int p;
	float x, y;
};
inline float distance(PointX &a, PointX &b) {
	return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
inline float distance(PointY& a, PointY& b) {
	return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}
void Merge(PointX Y[], int m, int n) {
	int i = 0, j = m, k = 0;
	PointX* temp = new PointX[n];
	while (i < m && j < n) {
		if (Y[i] <= Y[j]) {
			temp[k++] = Y[i++];
		}
		else {
			temp[k++] = Y[j++];
		}
	}
	while (i < m) {
		temp[k++] = Y[i++];
	}
	while (j < n) {
		temp[k++] = Y[j++];
	}
	for (int i = 0; i < n; i++) {
		Y[i] = temp[i];
	}
	delete[] temp;
}
void Merge(PointY X[], int m, int n) {
	int i = 0, j = m, k = 0;
	PointY* temp = new PointY[n];
	while (i < m && j < n) {
		if (X[i] <= X[j]) {
			temp[k++] = X[i++];
		}
		else {
			temp[k++] = X[j++];
		}
	}
	while (i < m) {
		temp[k++] = X[i++];
	}
	while (j < n) {
		temp[k++] = X[j++];
	}
	for (int i = 0; i < n; i++) {
		X[i] = temp[i];
	}
	delete[] temp;
}
//重构数组Y
void Merge(PointY Z[], PointY Y[], int l, int r) {
	for (int i = l; i <= r; i++) 
		Y[i] = Z[i];
}
void MergeSort(PointX X[], int n) {
	if (n < 2) {
		return;
	}
	int m = n / 2;
	MergeSort(X, m);
	MergeSort(X + m, n - m);
	Merge(X, m, n);
}
void MergeSort(PointY Y[], int n) {
	if (n < 2) {
		return;
	}
	int m = n / 2;
	MergeSort(Y, m);
	MergeSort(Y + m, n - m);
	Merge(Y, m, n);
}
void closest(PointX X[], PointY Y[], PointY Z[], int l, int r, PointX& a, PointX& b, float& d) {
	if (r - l == 1) {
		a = X[l];
		b = X[r];
		d = distance(X[l], X[r]);
		return;
	}
	if (r - l == 2) {
		float d1 = distance(X[l], X[l + 1]);
		float d2 = distance(X[l+1], X[r]);
		float d3 = distance(X[l], X[r]);
		if (d1 <= d2 && d1 <= d3) {
			a = X[l];
			b = X[l + 1];
			d = d1;
			return;
		}
		if (d2 <= d3) {
			a = X[l];
			b = X[r];
			d = d2;
		}
		else {
			a = X[l];
			b = X[r];
			d = d3;
		}
		return;
	}
	//多于三个点，分治法
	int m = (l + r) / 2;
	int f = l, g = m + 1;
	for (int i = l; i <= r; i++) {
		if (Y[i].p > m)
			Z[g++] = Y[i];
		else
			Z[f++] = Y[i];
	}
	closest(X, Z, Y, l, m, a, b, d);
	float dr;
	PointX ar, br;
	closest(X, Z, Y, m + 1, r, ar, br, dr);
	if (dr < d) {
		a = ar;
		b = br;
		d = dr;
	}
	//重构数组Y
	Merge(Z, Y, l, r);//把Z合并到Y中
	int k = l;
	for (int i = l; i <= r; i++) {
		if (fabs(X[m].x - Y[i].x) < d)
			Z[k++] = Y[i];
	}
	for (int i = l; i < k; i++) {
		for (int j = i + 1; j < k && Z[j].y - Z[i].y < d; j++) {
			float dp = distance(Z[i], Z[j]);
			if (dp < d) {
				d = dp;
				a = X[Z[i].p];
				b = X[Z[j].p];
			}
		}
	}
}
bool Cpair(PointX X[], int n, PointX& a, PointX& b, float &d) {
	if (n < 2) {
		return false;//没有点对
	}
	MergeSort(X, n);//按x排序
	PointY* Y = new PointY[n];
	for (int i = 0; i < n; i++)
	{
		Y[i].p = i;//记录Y中每个点的原始位置
		Y[i].x = X[i].x;
		Y[i].y = X[i].y;
	}
	MergeSort(Y, n);//按y排序
	PointY* Z = new PointY[n];
	closest(X, Y, Z, 0, n - 1, a, b, d);
	delete[] Y;
	delete[] Z;
	return true;
}
int main() {
	int n;
	cin >> n;
	PointX* X = new PointX[n];
	for (int i = 0; i < n; i++) {
		cin >> X[i].x >> X[i].y;
	}
	PointX a, b;
	float d=1.0;
	if (Cpair(X, n, a, b, d)) {
		cout << a.x << " " << a.y << endl;
		cout << b.x << " " << b.y << endl;
		cout << "distance=" << d << endl;
	}
	else {
		cout << "No pair found." << endl;
	}
	delete[] X;
	return 0;
}

测试样例

输入
在这里插入图片描述
输出
在这里插入图片描述

复杂度分析

T ( n ) = { 2 T ( n / 2 ) + O ( n ) n ≥ 4 O ( 1 ) n < 4 T(n)=\Big\{^{O(1) \quad n<4}_{2T(n/2)+O(n) \quad n≥ 4} T(n)={2T(n/2)+O(n)n≥4O(1)n<4​
T(n)=O(nlogn)

分治法求最近点对 （深大算法实验2）报告+代码
AKGWSB 's blog
06-27 1万+
所有实验的资源 链接: https://pan.baidu.com/s/1lukZRM3Rsd1la35EyyJcvg 提取码: iv72 目录写在前面问题描述求解问题的算法原理描述分治法分治法的改进：算法核心伪代码测试流程算法测试结果及效率分析总览与对比分治法：特殊情况的测试图形演示对求解这个问题的经验总结代码最近点对图形演示 写在前面 期末终于算法课快要完结了。 这学期算法课可谓是最难顶的课程了，又正好是线上上课，提问互动的机会相对较少，老师上课抛砖引玉，实验内容又比较难，我花了大部分的时间在找算法，
分治法平面最接近点对C++实现
12-03
这是一个典型的分治法应用实例，尤其是在点的数量非常大时，直接遍历所有点对会非常耗时。C++作为一门强大的编程语言，其高效的数据结构和算法库使得处理这类问题变得可能。 C++实现平面最接近点对问题通常包括以下...
最近点对问题 分治法 C++实现
SnowLightning的博客
10-08 800
最近点对问题的分治法实现（C++）
Leetcode打卡日记3月18日
qq_42311614的博客
03-18 165
矩形重叠 矩形以列表 [x1, y1, x2, y2] 的形式表示，其中 (x1, y1) 为左下角的坐标，(x2, y2) 是右上角的坐标。 如果相交的面积为正，则称两矩形重叠。需要明确的是，只在角或边接触的两个矩形不构成重叠。 给出两个矩形，判断它们是否重叠并返回结果。 示例 1： 输入：rec1 = [0,0,2,2], rec2 = [1,1,3,3] 输出：true 示例 2： ...
分治法求解最近对问题（c++）
weixin_30596735的博客
02-26 451
#include"stdafx.h" #include<iostream> #include<cmath> #define TRUE 1 #define FALSE 0 using namespace std; typedef struct Node//坐标点 { double x; double y; }Node; typed...
最近点对问题——分治、蛮力时间性能对比
ItaLink
04-11 965
#include<iostream> #include<vector> #include<cmath> #include<algorithm> #include<Windows.h> #include<time.h> using namespace std; struct Point { //点 int x, y; ...
【分治法】棋盘覆盖问题 C/C++（附代码和测试实例及算法分析）
lhr056813的博客
02-18 1562
本文介绍了使用分治法解决棋盘覆盖问题的方法，并分析了算法的时间复杂度，附代码和测试实例
详细实例说明+典型案例实现 对分治法进行全面分析 | C++
PIONEER
01-13 2508
简单的来说，算法就是用计算机程序代码来实现数学思想的一种方法。学习算法就是为了了解它们在计算机中如何演算，以及在当今的信息时代，它们是如何在各个层面上影响我们的日常生活的，从而提高我们的逻辑思维能力和处理实际问题的能力。善用算法、巧用算法，是培养程序设计逻辑的重中之重，许多实际的问题都可用多个可行的算法来解决， 但是要从中找出最优的解决算法却是一项挑战。分治法是一种很重要的算法，我们可以用分治法去逐一拆解复杂的问题，使复杂问题简单化。
【分治法】循环赛日程表问题 C\C++（附代码、实例）
lhr056813的博客
02-21 1085
本文介绍了使用分治策略解决循环赛日程表问题的方法，包括递归和非递归实现，附代码、实例
最近点对问题c语言源程序,C++实例:最近点对问题
weixin_39901412的博客
05-22 551
通过代码来学习实例，看下面的代码：//点结构typedef struct Pair{int x ;int y ;} Pair ;//最近点对结构typedef struct Closest_Pair{Pair pair_a ,pair_b ;double distance ;} Closest_Pair ;//点对结构typedef struct Points{Pair* p_pair ;int ...
汉诺塔问题 分治法——C++代码
05-24
在编程课程中，汉诺塔问题通常作为理解和实践分治法的实例。通过编写和运行代码，学生可以直观地理解递归工作原理，并学习如何将大问题分解为小问题来解决。此外，该问题还涉及到算法效率、递归边界条件和递归函数的...
最近对问题 分治法 ——C语言代码
05-23
分治法是计算机科学中一种重要的算法设计策略，它的核心思想是将一个复杂的问题分解成两个或更多的相同或相似的子问题，直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。在C语言中实现分治法，...
归并排序 分治法——C++代码
05-24
归并排序是一种高效的排序算法，基于“分治”策略。...归并排序是分治法的一个典型应用实例，通过将问题分解、解决子问题然后组合结果来达到全局解决方案。理解并掌握这些算法可以帮助我们解决更复杂的编程挑战。
代码随想录算法训练营Day31 | 56. 合并区间 738.单调递增的数字
m0_74154872的博客
04-26 287
一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间。表示若干个区间的集合，其中单个区间为。请你合并所有重叠的区间，并返回。当且仅当每个相邻位数上的数字。的最大数字，且数字呈。时，我们称这个整数是。
算法之动态规划
qq_68194402的博客
04-21 1700
动态规划（Dynamic Programming, DP）是一种解决复杂问题的算法设计技术，适用于具有“重叠子问题”和“最优子结构”性质的问题。动态规划将问题分解成更小的子问题，通过解决这些子问题来解决原始问题。这种方法的关键在于避免重复计算。一旦解决了一个子问题，它的解就被存储起来，以便后续需要时直接使用，从而避免了重复计算。这种记忆化的技术称为“缓存”。
【Torch】MaxPool1d、MaxPool2d、MaxPool3d算法详解
zkw54334的博客
04-29 741
MaxPool1d 就是“挑时间窗口里最强的响应”来下采样——通道（特征）的语义不变，只有时间分辨率被压缩，从而提取局部最显著的时序信息并减少后续计算量。
基础排序方法
最新发布
2301_79976271的博客
04-29 960
1.基本思想直接插入排序的实现，我们可以参考扑克牌的排序当我们要将新的牌插入现有牌堆时，保证当前手中的牌堆有序，再将新的牌与牌堆中的值进行比较，在进行比较与交换后，现在的牌堆就有序了。2.具体实现我们先进行单趟排序的实现，假设[0,end]的元素有序，这里即设第一个元素为有序的。此时要进行排序的元素为a[end+1]，将该元素依次与现有的有序牌堆进行比较。若当前值小于end处的值，交换。
(leetcode) 力扣100 4.移动零(两种O(n)方法 双指针)
qq_62235017的博客
04-29 233
博主采用的思路很简单，不管原始数组如何，最后得到的数组形式是一样的，前面一串非0数字，最后几个连续的0，那么就不需要考虑交换的逻辑，而是去把数字放到他最后应该存在的位置即可。这道题整体思路简单，但题目提到，不能新建数组，那么目的很明确了，就是要求你在O（1）的空间复杂度和O（n）的时间复杂度完成这道题。整体来说，对于没接触过或不熟悉双指针的人来说，官方题解虽然优雅，但还是具有一定的思维难度，大家多联系即可。给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
C++实现最近点对分治算法实例分析
对于本文件"最近点对问题 分治法.cpp.rar"，尽管描述中提到老师可能不会太仔细检查，但是从学习的角度来看，理解分治法解决最近点对问题的原理和实现细节对学习C++和计算几何都是非常有益的。阅读和理解这个程序可以...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值