查找最近的点对-如何在递归侧对函数调用中实现拆分对
Finding the closest pair of points - How to implement split pairs inside recursive side pairs function calls
我正在尝试使用分治法实现找到最接近的点对算法。
首先解释一下,分裂对(p1, p2)是最近的一对,使得p1在左边,p2在右边。边对(p3, p4)是最接近的对,使得p3和p4在一边。
我已经完成了实现,它返回正确的结果,但只有当closest_split_pairs
函数被单独调用(不在closest_side_pairs
函数内)。所以如果我提供这些点:
2,1
8,3
5,8
9,1
5,2
3,3
4,5
6,5
1,9
2,1.5
我得到2,1
和2,1.5
的结果。
但是如果我在closest_side_pairs
里面调用closest_split_pair
(我认为它应该是这样的)..我得到一个错误的结果3,3
和4,5
。问题是我不知道该怎么做才能将closest_split_pairs
整合到closest_side_pairs
中。以下是在closest_side_pairs
内部调用closest_split_pairs
的代码,单独的调用在main
函数中注释。
#include <iostream>
#include <array>
#include <algorithm>
#include <fstream>
#include <cfloat>
#include <cmath>
struct Point {
Point(double x = 0, double y = 0) {
x_coordinate = x;
y_coordinate = y;
}
double x_coordinate;
double y_coordinate;
static bool sortByX(const Point &lhs, const Point &rhs) {
return lhs.x_coordinate < rhs.x_coordinate;
}
static bool sortByY(const Point &lhs, const Point &rhs) {
return lhs.y_coordinate < rhs.y_coordinate;
}
};
using p_iterator = std::vector<Point>::iterator;
template<std::size_t SIZE>
using p_iterators_array = std::array<std::vector<Point>::iterator, SIZE>;
void initialize_points(std::vector<Point> &points) {
double x, y;
char c;
std::ifstream infile("./points.txt");
while((infile >> x >> c >> y) && (c == ',')) {
points.push_back(Point(x, y));
}
}
double calculate_distance(Point &p1, Point &p2) {
return std::sqrt(std::pow(p1.x_coordinate - p2.x_coordinate, 2) + std::pow(p1.y_coordinate - p2.y_coordinate , 2));
}
template<typename T>
p_iterators_array<2> eucledian_closest(T &points, int size) {
p_iterators_array<2> closest_arr;
double closest_distance = DBL_MAX, distance = 0.0;
for(int i = 0; i < size - 1; i++){
for(int j = i + 1; j < size; j++) {
distance = calculate_distance(points[i], points[j]);
if(distance < closest_distance ) {
closest_distance = distance;
closest_arr[0] = points + i;
closest_arr[1] = points + j;
}
}
}
return closest_arr;
}
p_iterators_array<2> closest_split_pair(p_iterator points_iterator, p_iterators_array<2> &closest_side_pairs, std::size_t size) {
std::vector<p_iterator> split_pairs;
p_iterators_array<2> final_result;
double closest_distance = DBL_MAX, distance = 0.0;
p_iterator midpoint = points_iterator + (size/2);
//filtering points to only points in sigma-2sigma rectangle
for (size_t i = 0; i < size; i++) {
if(std::abs(points_iterator[i].x_coordinate - midpoint->x_coordinate) < calculate_distance(*(closest_side_pairs[0]), *(closest_side_pairs[1]))){
split_pairs.push_back(points_iterator + i);
}
}
//finding closest pair in split_pairs
for (size_t i = 0; i < split_pairs.size() - 1; i++) {
for (size_t j = i+1; (j < 7) && (j < split_pairs.size()) ; j++) {
distance = calculate_distance(*(split_pairs[i]), *(split_pairs[j]));
if(distance < closest_distance ) {
closest_distance = distance;
final_result[0] = split_pairs[i];
final_result[1] = split_pairs[j];
}
}
}
//comparing split paris distance and side pairs distance
if(calculate_distance(*(closest_side_pairs.front()), *(closest_side_pairs.back())) < calculate_distance(*(final_result.front()), *(final_result.back()))) {
final_result = closest_side_pairs;
}
return final_result;
}
p_iterators_array<2> closest_side_pair(p_iterator points_iterator, p_iterator x_arr_iterator, p_iterator y_arr_iterator, std::size_t size) {
std::size_t delimeter = size / 2 ;
if(delimeter <= 3) {
return eucledian_closest(points_iterator, delimeter);
}
p_iterators_array<2> closest_left, closest_right, result;
closest_left = closest_side_pair(points_iterator, x_arr_iterator, y_arr_iterator, delimeter);
closest_right = closest_side_pair(points_iterator + delimeter, x_arr_iterator + delimeter, y_arr_iterator + delimeter, delimeter);
if(calculate_distance(*(closest_left.front()), *(closest_left.back())) < calculate_distance(*(closest_right.front()), *(closest_right.back()))) {
result = closest_left;
} else {
result = closest_right;
}
return closest_split_pair(points_iterator, result, delimeter);
}
int main()
{
std::vector<Point> points;
initialize_points(points);
std::vector<Point> x_p = points;
std::vector<Point> y_p = points;
std::sort(x_p.begin(), x_p.end(), Point::sortByX);
std::sort(y_p.begin(), y_p.end(), Point::sortByY);
p_iterators_array<2> closest_result = closest_side_pair(points.begin(), x_p.begin(), y_p.begin(), points.size());
//Separate call of closest_split_pair
//closest_result = closest_split_pair(points.begin(), closest_result, points.size());
std::cout << "Closest pair are: " << std::endl;
for(auto p: closest_result) {
std::cout << p->x_coordinate << ", " << p->y_coordinate << std::endl;
}
}
您在closest_side_pair
例程中有几个错误。
调用eucledian_closest
例程时,传递给该函数的向量长度是delimiter
,而应该是size
。类似地,当调用closest_split_pair
时,传递的向量长度为delimiter
。应该是size
。
目前closest_split_pair
所做的是,它假设中点在points_iterator + delimiter/2
,你希望它在points_iterator + size/2
。这看起来会令人困惑,但只要将closest-side_pair
中的'delimiter'替换为'size',你的代码就可以工作了。
相关文章:
- 如何在Elixir中调用递归函数并行
- 我在 C++ 中创建了一个函数来递归反转字符串,但是之后如何使功能打印一个 endl?
- 如何通过函数指针递归调用类成员函数?
- 使用带有一个参数函数的递归找到数字的平方
- 返回不停止函数,递归函数问题?(编程练习,动态规划,Levenshtein 回溯)
- 对可变参数函数的递归调用的链接器错误
- 从 C++ 中的函数返回递归 lambda
- 函数以递归逆转链接的列表
- C - 为什么合并函数在递归调用后会逆转数组
- 系统堆栈中的两个函数的递归调用(将不同数量的数组作为参数传递)有什么区别
- 对具有传递引用参数的函数使用递归
- (C++)对文件输入函数的递归调用
- 二叉树析构函数的递归调用
- 在循环中调用递归函数
- 如何计算对该函数的递归调用,以及正确答案是什么
- ambigus调用递归sudoku_backtracker函数
- 如何在C++中调用递归链表遍历函数
- 为什么在NULL检查之后要在指针上调用递归函数?
- 通过结构调用递归函数
- 如果在指令之前调用递归函数怎么办