目前C++17计算全部N个点的两两距离最快的算法是什么?_c++求两点间距离的函数

由网友 船骑世界 提供的答案：

计算所有N个点之间的两两距离是一个常见的计算机图形学问题和计算几何问题。 在C++17中,最快的算法可能是使用多线程和SIMD指令优化的KD-Tree算法。

KD-Tree是一种高效的数据结构,可以用于在多维空间中查找最近邻。在计算点之间的两两距离时,KD-Tree可以将点集分成不同的区域,并且不需要计算所有点对之间的距离。这种算法可以极大地提高计算效率。

可以使用OpenMP指令集,让程序并行化处理,同时使用SIMD指令集对并行化程序进行优化,可以进一步提高程序的性能。可以使用诸如Eigen或Boost.Geometry之类的库来实现这个算法。然而,具体实现还需要根据具体的问题和数据集来调整算法的具体实现,因此需要根据具体情况进行进一步研究和开发。

由网友 挚手擎天 提供的答案：

C++17并没有直接支持计算全部N个点的两两距离的算法。但是,可以通过一些优化算法来实现快速计算,如：

1. 广义Morton码（Z-Order排序）：将所有的点映射到一个一维的空间上,使得离得近的点在一维空间上也靠得近。通过广义Morton码可以实现高效的空间分区,使得一些常见的算法如KD树等能够快速地处理大规模数据。

2. 分块（Block decomposition）：将所有的点均匀地分割成若干个块（Block）,然后针对每个小块,可以通过简单的暴力算法计算每个块内的两两距离；而对于不同的块之间,可以采取不同的高效算法,如KD树等。

3. KD树（K-Dimensional Tree）：通过不断地基于每个维度找出中位数来建立一颗二叉树,可以高效地对高维数据进行搜索。

4. 最短路算法（Floyd, Warshall, Dijkstra）：最短路算法可以求解任意两点之间的最短距离,但是对于大规模数据,时间复杂度较高。 需要注意的是,以上算法中的具体实现方式与数据的特点、分布情况等有关,需要针对不同的数据集进行选择、调整和优化。

由网友 创客媒体 提供的答案：

在C++17中,计算N个点之间的两两距离的最快算法会涉及高效的数据结构和算法选择。以下是一种常见的优化算法：

1. 使用平方根：首先,考虑到计算欧氏距离时需要开方操作,可以通过使用距离的平方来避免开方运算。这样可以大大减少计算量。
2. 使用平行计算：考虑使用并行计算,将计算任务分发给多个处理器核心同时执行。在C++17中,可以使用<algorithm>头文件中的std::for_each或std::transform结合std::execution::par来实现并行计算。请确保您的编译器和系统支持并行执行。
3. 选择适当的数据结构：选择适当的数据结构以存储点的坐标信息。在这种情况下,使用一维或二维数组来存储点的坐标可能是高效的,因为可以通过索引直接访问点的坐标,而无需进行额外的查找。
4. 减少重复计算：在计算两个点之间的距离时,可以避免重复计算。可以使用嵌套循环来遍历点对,并使用条件语句来跳过已经计算过的点对。

以下是一个简单示例,演示如何使用上述优化策略来计算N个点的两两距离：

cppCopy code

#include <iostream> #include <vector> #include <cmath> #include <algorithm> #include <execution> struct Point { double x, y; }; // 计算两点之间的平方距离 double distanceSquared(const Point& p1, const Point& p2) { double dx = p2.x - p1.x; double dy = p2.y - p1.y; return dx * dx + dy * dy; } // 计算所有点的两两距离 std::vector<double> computeDistances(const std::vector<Point>& points) { std::vector<double> distances; distances.reserve(points.size() * (points.size() - 1) / 2); for (size_t i = 0; i < points.size(); ++i) { for (size_t j = i + 1; j < points.size(); ++j) { double dist = distanceSquared(points[i], points[j]); distances.push_back(dist); } } return distances; } int main() { std::vector<Point> points = { {0.0, 0.0}, {1.0, 1.0}, {2.0, 2.0}, {3.0, 3.0} }; // 计算距离 std::vector<double> distances = computeDistances(points); // 输出结果 for (const double& dist : distances) { std::cout << "Distance: " << std::sqrt(dist) << std::endl; } return 0; }

这只是一个简单示例,并未包含并行计算。要使用并行计算,您可以将std::transform与std::execution::par结合使用来并行计算距离。下面是一个示例代码：

cppCopy code

std::vector<double> computeDistances(const std::vector<Point>& points) { std::vector<double> distances; distances.resize(points.size() * (points.size() - 1) / 2); // 并行计算距离 std::transform(std::execution::par, points.begin(), points.end()-1, distances.begin(), [&](const Point& p1) { std::vector<double> row_distances; row_distances.reserve(points.size() - 1); for (auto it = std::next(std::find(points.begin(), points.end(), p1)); it != points.end(); ++it) { double dist = distanceSquared(p1, *it); row_distances.push_back(dist); } return row_distances; }); // 将结果展开为一维向量 std::vector<double> flattened_distances; for (const auto& row : distances) { flattened_distances.insert(flattened_distances.end(), row.begin(), row.end()); } return flattened_distances; }

请注意,实际的性能取决于您的硬件、编译器和输入数据的规模。在使用并行计算时,还需要考虑到并行操作可能带来的额外开销,并确保对共享数据进行正确的同步和互斥处理。

此外,还有其他的优化策略和数据结构可以用于加速计算两点之间的距离,例如使用KD树或四叉树等空间分区数据结构。根据具体的应用场景和需求,您可能需要进一步调整算法和数据结构的选择。

由网友 Zacktod 提供的答案：

对于计算10000个点的两两距离并存储在`map<pair<P*, P*>, double>`中,可以考虑使用以下算法：

1. 首先,使用一个循环遍历所有的点对组合（N*(N-1)/2个点对）,其中N为点的总数。为了保持顺序,确保较小地址的点在前,较大地址的点在后。

2. 对于每个点对`(p1, p2)`,计算它们之间的距离,并将距离存储在`map<pair<P*, P*>, double>`中。

以下是一个示例代码片段,展示如何实现上述算法：

#include <iostream>

#include <map>

#include <cmath>

struct P {

double x;

double y;

double z;

};

// 计算两点之间的距离

double calculateDistance(const P& p1, const P& p2) {

double dx = p1.x - p2.x;

double dy = p1.y - p2.y;

double dz = p1.z - p2.z;

return std::sqrt(dx*dx + dy*dy + dz*dz);

}

int main() {

const int N = 10000;

std::map<std::pair<P*, P*>, double> distances;

// 假设points是一个包含N个点的数组

P points[N];

// 计算距离并存储在map中

for (int i = 0; i < N; ++i) {

for (int j = i + 1; j < N; ++j) {

double distance = calculateDistance(points[i], points[j]);

distances[std::make_pair(&points[i], &points[j])] = distance;

}

}

// 使用距离map进行后续操作...

return 0;

}

这段代码通过两个嵌套的循环遍历所有点对,计算它们之间的距离,并将距离存储在`distances` map中。请注意,这只是一个简单的示例,你可能需要根据实际需求进行适当的修改和优化。

在实际情况中,如果你的需求是高性能的,可以考虑使用并行计算或其他优化技术来加速计算过程。另外,如果你使用的是具有硬件加速特性的库,如Eigen、OpenBLAS等,可以进一步提高计算速度。

由网友 醉览天下事 提供的答案：

计算N个点的两两距离最快的算法之一是使用 OpenMP 并行化的 Floyd-Warshall 算法。这种算法的时间复杂度为 O(N^3),对于较小的 N 可能不太适用,但是可以通过并行化来加速计算。

Floyd-Warshall 算法是一种经典的动态规划算法,可以在一个完全连接的加权图中求出所有节点间的最短路径。该算法使用了一个 N×N 的二维数组,并通过三重循环遍历矩阵来更新节点间距离的值,因此时间复杂度为 O(N^3)。

使用 OpenMP 可以将 Floyd-Warshall 算法并行化,通过多线程处理矩阵的多个部分来提高性能。在并行化的过程中需要注意避免数据竞争和线程同步问题,需要使用 OpenMP 提供的原子操作或互斥量等机制来保证并发访问的正确性。

除了 Floyd-Warshall 算法之外,还有其他一些计算两两距离的算法可以使用,例如 Dijkstra 算法、Prim 算法、Kruskal 算法、最短路径树算法等。这些算法通常的时间复杂度为 O(N^2 log N) 或者 O(N log N),但是它们都需要先建立一张加权图,因此可能会比 Floyd-Warshall 算法更加复杂和耗时。