Bazı haritaların ve bazı köklerin yer alması, standart algoritmanın yol yaratmada ne gibi yardımcı olacağını görmek ister miyiz?

Question

Bazı nokta noktalarımız var (her noktanın X ve Y değeri vardır) ve çok yönlü bir kök haritası [nokta, nokta]. Kökler aracılığıyla herhangi bir noktadan herhangi bir yönden herhangi bir yöne doğru hareket edebiliriz.

olarak hem olarak görünecektir: Böyle bir yolunu nasıl hesaplanacağını

: Biz mümkün olduğunca yakın takip etmek istediğiniz 2d noktalardan bazılarını yolunu verilir verilen yol mümkün mü? Böyle bir şey yapabilen kullanışlı algoritmalar nelerdir (ve Boons Geometry veya Graph veya herhangi bir diğer genel kaynak C++ kütüphanesi)?

Answer 1

Bu gerçekten sevimli küçük bir sorundur. Grafiğiniz iyi bağlanmışsa, açgözlü bir yaklaşım oldukça işe yarayabilir. Aşağıdaki gibi: (1) mevcut pozisyonu, yolun başlangıcına en yakın düğüm olacak şekilde ayarlayın, (2) daha yakın nokta olmayana kadar yoldaki bir sonraki noktaya en yakın olan bitişik düğüme ilerleyin, (3) yolunda bir sonraki nokta ve bitmezse goto (2). Bu algoritma döngülerinde sıkışırsa

#include <assert.h> 
#include <stddef.h> 
#include <iostream> 
#include <iterator> 
#include <vector> 
#include <limits> 

double sq(double const d) 
{ 
    return d * d; 
} 

size_t min_dist_point(
    std::vector<double> const& x, 
    std::vector<double> const& y, 
    std::vector<bool> const& adjacent, 
    double const fx, 
    double const fy 
) 
{ 
    size_t const points = x.size(); 

    double min_dist_sq = std::numeric_limits<double>::max(); 
    size_t min_point; 

    for (size_t j = 0; j < points; ++j) { 
     if (!adjacent[j]) { continue; } 
     double const dist_sq = sq(x[j] - fx) + sq(y[j] - fy); 

     if (dist_sq < min_dist_sq) { 
      min_point = j; 
      min_dist_sq = dist_sq; 
     } 
    } 
    assert(min_dist_sq != std::numeric_limits<double>::max()); 

    return min_point; 
} 

template <class out_t> 
out_t f(
    std::vector<double> const& x, 
    std::vector<double> const& y, 
    std::vector<std::vector<bool> > adjacent, 
    std::vector<double> const& follow_x, 
    std::vector<double> const& follow_y, 
    out_t out 
) 
{ 
    size_t const points = x.size(); 
    size_t const follow_len = follow_x.size(); 
    for (size_t i = 0; i < points; ++i) { 
     adjacent[i][i] = 1; 
    } 

    std::vector<bool> const all (points, true); 
    size_t pos = min_dist_point(x, y, all, follow_x[0], follow_y[0]); 
    *out++ = pos; 

    for (size_t i = 1; i < follow_len; ++i) { 
     for (;;) { 
      size_t const next = min_dist_point(x, y, adjacent[pos], follow_x[i], follow_y[i]); 
      if (next == pos) { break; } 
      *out++ = (pos = next); 
     } 
    } 

    return out; 
} 

A * arama gerekecektir.

http://www.boost.org/doc/libs/1_47_0/libs/graph/doc/astar_search.html