Как найти наиболее близкие места для списка мест более эффективным способом?

Если евклидово расстояние хорошо, то nn2 использует kd-деревья и код C, поэтому он должен быть быстрым:

library(RANN)
nn2(df[2:3], k = 4)

Это заняло в среднем 0,06-0,11 секунды на моем не очень быстром ноутбуке для обработки n = 10 000 строк и в общей сложности от 1,00 до 1,25 секунды для 90 000 строк.

Я могу предложить решение python с scipy

from scipy.spatial import distance
from geopy.distance import vincenty
v=distance.cdist(df[['lat','lon']].values,df[['lat','lon']].values,lambda u, v: vincenty(u, v).kilometers)
np.sort(v,axis=1)[:,1:4]
Out[1033]: 
array([[384.09948155, 468.15944729, 545.41393271],
   [270.07677993, 397.21974571, 659.96238603],
   [384.09948155, 397.21974571, 619.616239  ],
   [203.07302273, 483.54687912, 741.21396029],
   [203.07302273, 444.49156394, 659.96238603],
   [437.31308598, 468.15944729, 494.91879983],
   [494.91879983, 695.91437812, 697.27399161],
   [270.07677993, 444.49156394, 483.54687912],
   [530.54946479, 626.29467739, 695.91437812],
   [437.31308598, 545.41393271, 697.27399161]])

Вот как решить эту проблему с помощью C++ и моей библиотеки GeographicLib (версия 1.47 или новее). Это использует истинные эллипсоидальные геодезические расстояния и дерево точек видимости для оптимизации поиска ближайших соседей.

#include <exception>
#include <vector>
#include <fstream>
#include <string>

#include <GeographicLib/NearestNeighbor.hpp>
#include <GeographicLib/Geodesic.hpp>

using namespace std;
using namespace GeographicLib;

// A structure to hold a geographic coordinate.
struct pos {
  string id;
  double lat, lon;
  pos(const string& _id = "", double _lat = 0, double _lon = 0) :
    id(_id), lat(_lat), lon(_lon) {}
};

// A class to compute the distance between 2 positions.
class DistanceCalculator {
private:
  Geodesic _geod;
public:
  explicit DistanceCalculator(const Geodesic& geod) : _geod(geod) {}
  double operator() (const pos& a, const pos& b) const {
    double d;
    _geod.Inverse(a.lat, a.lon, b.lat, b.lon, d);
    if ( !(d >= 0) )
      // Catch illegal positions which result in d = NaN
      throw GeographicErr("distance doesn't satisfy d >= 0");
    return d;
  }
};

int main() {
  try {
    // Read in pts
    vector<pos> pts;
    string id;
    double lat, lon;
    {
      ifstream is("pts.txt");   // lines of "id lat lon"
      if (!is.good())
        throw GeographicErr("pts.txt not readable");
      while (is >> id >> lon >> lat)
        pts.push_back(pos(id, lat, lon));
      if (pts.size() == 0)
        throw GeographicErr("need at least one location");
    }

    // Define a distance function object
    DistanceCalculator distance(Geodesic::WGS84());

    // Create NearestNeighbor object
    NearestNeighbor<double, pos, DistanceCalculator>
      ptsset(pts, distance);

    vector<int> ind;
    int n = 3;                  // Find 3 nearest neighbors
    for (unsigned i = 0; i < pts.size(); ++i) {
      ptsset.Search(pts, distance, pts[i], ind,
                    n, numeric_limits<double>::max(),
                    // exclude the point itself
                    0.0);
      if (ind.size() != n)
          throw GeographicErr("unexpected number of results");
      cout << pts[i].id;
      for (unsigned j = 0; j < ind.size(); ++j)
        cout << " " << pts[ind[j]].id;
      cout << "\n";
    }
    int setupcost, numsearches, searchcost, mincost, maxcost;
    double mean, sd;
    ptsset.Statistics(setupcost, numsearches, searchcost,
                      mincost, maxcost, mean, sd);
    long long
      totcost = setupcost + searchcost,
      exhaustivecost = ((pts.size() - 1) * pts.size())/2;
    cerr
      << "Number of distance calculations = " << totcost << "\n"
      << "With an exhaustive search = " << exhaustivecost << "\n"
      << "Ratio = " << double(totcost) / exhaustivecost << "\n"
      << "Efficiency improvement = "
      << 100 * (1 - double(totcost) / exhaustivecost) << "%\n";

  }
  catch (const exception& e) {
    cerr << "Caught exception: " << e.what() << "\n";
    return 1;
  }
}

Это читает в наборе точек (в форме "id lat lon") для pts.txt, помещает их в дерево VP. Затем для каждой точки он просматривает 3 ближайших соседа и печатает идентификатор и идентификатор соседей (ранжированных по расстоянию).

Скомпилируйте это, например,

g++ -O3 -o nearest nearest.cpp -lGeographic

Если pts.txt содержит 90000 точек, то вычисление завершается примерно через 6 секунд (или 70 мкс на точку) на моем домашнем компьютере после выполнения 3380000 дистанционных вычислений. Это примерно в 1200 раз эффективнее расчета грубой силы (все вычисления расстояний N (N - 1)/2).

Вы можете ускорить это (в несколько раз), используя грубое приближение к расстоянию (например, сферическое или евклидово); просто измените класс DistanceCalculator соответствующим образом. Например, эта версия DistanceCalculator возвращает сферическое расстояние в градусах:

// A class to compute the spherical distance between 2 positions.
class DistanceCalculator {
public:
  explicit DistanceCalculator(const Geodesic& /*geod*/) {}
  double operator() (const pos& a, const pos& b) const {
    double sphia, cphia, sphib, cphib, somgab, comgab;
    Math::sincosd(a.lat, sphia, cphia);
    Math::sincosd(b.lat, sphib, cphib);
    Math::sincosd(Math::AngDiff(a.lon, b.lon), somgab, comgab);
    return Math::atan2d(Math::hypot(cphia * sphib - sphia * cphib * comgab,
                                    cphib * somgab),
                        sphia * sphib + cphia * cphib * comgab);
  }
};

Но теперь у вас есть дополнительное бремя обеспечения достаточности аппроксимации. Я рекомендую просто использовать правильное геодезическое расстояние в первую очередь.

Детали реализации деревьев VP в GeographicLib приведены здесь.