Open-Harbor/osrm-backend
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 3 Wiki Activity

change input param for tsp algos from a vector to a begin and an end iterator

Browse Source
This commit is contained in:
Huyen Chau Nguyen 2015-08-20 01:41:36 +02:00
parent 2de3fc9f6f
commit 93835b9b94
4 changed files with 157 additions and 165 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

147
plugins/round_trip.hpp
View File

@ -60,6 +60,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <utility> #include <utility>
#include <vector> #include <vector>
#include <limits> #include <limits>
#include <map>
#include <iterator> #include <iterator>
#include <iostream> #include <iostream>
@ -105,26 +106,56 @@ template <class DataFacadeT> class RoundTripPlugin final : public BasePlugin
} }
} }
void SplitUnaccessibleLocations(const std::size_t number_of_locations, struct SCC_Component{
const DistTableWrapper<EdgeWeight> & result_table, SCC_Component(std::vector<NodeID> in_component,
std::vector<std::vector<NodeID>> & components) { std::vector<size_t> in_component_range)
: component(in_component), component_range(in_component_range) {
component_range.push_back(in_component.size());
};
SCC_Component(std::vector<NodeID> in_component)
: component(in_component), component_range({0, in_component.size()}) {
};
std::size_t GetNumberOfComponents() const{
return component_range.size() - 1;
}
const std::vector<NodeID> component;
std::vector<size_t> component_range;
};
SCC_Component SplitUnaccessibleLocations(const std::size_t number_of_locations,
const DistTableWrapper<EdgeWeight> & result_table) {
// Run TarjanSCC // Run TarjanSCC
auto wrapper = std::make_shared<MatrixGraphWrapper<EdgeWeight>>(result_table.GetTable(), number_of_locations); auto wrapper = std::make_shared<MatrixGraphWrapper<EdgeWeight>>(result_table.GetTable(), number_of_locations);
auto scc = TarjanSCC<MatrixGraphWrapper<EdgeWeight>>(wrapper); auto scc = TarjanSCC<MatrixGraphWrapper<EdgeWeight>>(wrapper);
scc.run(); scc.run();
std::vector<size_t> range_insertion;
std::vector<size_t> component_range;
range_insertion.reserve(scc.get_number_of_components());
component_range.reserve(scc.get_number_of_components());
std::vector<NodeID> components(number_of_locations, 0);
auto prefix = 0;
for (size_t j = 0; j < scc.get_number_of_components(); ++j){ for (size_t j = 0; j < scc.get_number_of_components(); ++j){
components.push_back(std::vector<NodeID>()); range_insertion.push_back(prefix);
component_range.push_back(prefix);
prefix += scc.get_component_size(j);
} }
for (size_t i = 0; i < number_of_locations; ++i) { for (size_t i = 0; i < number_of_locations; ++i) {
components[scc.get_component_id(i)].push_back(i); components[range_insertion[scc.get_component_id(i)]] = i;
} ++range_insertion[scc.get_component_id(i)];
} }
template <typename number> return SCC_Component(components, component_range);
void SetLocPermutationOutput(const std::vector<number> & loc_permutation, osrm::json::Object & json_result){ }
void SetLocPermutationOutput(const std::vector<NodeID> & loc_permutation, osrm::json::Object & json_result){
osrm::json::Array json_loc_permutation; osrm::json::Array json_loc_permutation;
json_loc_permutation.values.insert(std::end(json_loc_permutation.values), std::begin(loc_permutation), std::end(loc_permutation)); json_loc_permutation.values.insert(std::end(json_loc_permutation.values), std::begin(loc_permutation), std::end(loc_permutation));
json_result.values["loc_permutation"] = json_loc_permutation; json_result.values["loc_permutation"] = json_loc_permutation;
@ -137,7 +168,9 @@ template <class DataFacadeT> class RoundTripPlugin final : public BasePlugin
json_result.values["runtime"] = runtime; json_result.values["runtime"] = runtime;
} }
void SetGeometry(const RouteParameters &route_parameters, const InternalRouteResult & min_route, osrm::json::Object & json_result) { void SetGeometry(const RouteParameters &route_parameters,
const InternalRouteResult & min_route,
osrm::json::Object & json_result) {
// return geometry result to json // return geometry result to json
std::unique_ptr<BaseDescriptor<DataFacadeT>> descriptor; std::unique_ptr<BaseDescriptor<DataFacadeT>> descriptor;
descriptor = osrm::make_unique<JSONDescriptor<DataFacadeT>>(facade); descriptor = osrm::make_unique<JSONDescriptor<DataFacadeT>>(facade);
@ -152,28 +185,14 @@ template <class DataFacadeT> class RoundTripPlugin final : public BasePlugin
InternalRouteResult & min_route) { InternalRouteResult & min_route) {
// given he final trip, compute total distance and return the route and location permutation // given he final trip, compute total distance and return the route and location permutation
PhantomNodes viapoint; PhantomNodes viapoint;
for (auto it = std::begin(trip); it != std::prev(std::end(trip)); ++it) { for (auto it = std::begin(trip); it != std::end(trip); ++it) {
auto from_node = *it; const auto from_node = *it;
auto to_node = *std::next(it); const auto to_node = std::next(it) != std::end(trip) ? *std::next(it) : *std::begin(trip);
viapoint = PhantomNodes{phantom_node_vector[from_node][0], phantom_node_vector[to_node][0]}; viapoint = PhantomNodes{phantom_node_vector[from_node][0], phantom_node_vector[to_node][0]};
min_route.segment_end_coordinates.emplace_back(viapoint); min_route.segment_end_coordinates.emplace_back(viapoint);
} }
// check dist between last and first location too
viapoint = PhantomNodes{phantom_node_vector[*std::prev(std::end(trip))][0], phantom_node_vector[trip.front()][0]};
min_route.segment_end_coordinates.emplace_back(viapoint);
search_engine_ptr->shortest_path(min_route.segment_end_coordinates, route_parameters.uturns, min_route);
}
void ComputeRoute(const PhantomNodeArray & phantom_node_vector, search_engine_ptr->shortest_path(min_route.segment_end_coordinates, route_parameters.uturns, min_route);
const RouteParameters & route_parameters,
std::vector<std::vector<NodeID>> & trip,
std::vector<InternalRouteResult> & route) {
for (const auto & curr_trip : trip) {
InternalRouteResult curr_route;
ComputeRoute(phantom_node_vector, route_parameters, curr_trip, curr_route);
route.push_back(curr_route);
search_engine_ptr->shortest_path(route.back().segment_end_coordinates, route_parameters.uturns, route.back());
}
} }
int HandleRequest(const RouteParameters &route_parameters, int HandleRequest(const RouteParameters &route_parameters,
@ -184,6 +203,7 @@ template <class DataFacadeT> class RoundTripPlugin final : public BasePlugin
return 400; return 400;
} }
// get phantom nodes
PhantomNodeArray phantom_node_vector(route_parameters.coordinates.size()); PhantomNodeArray phantom_node_vector(route_parameters.coordinates.size());
GetPhantomNodes(route_parameters, phantom_node_vector); GetPhantomNodes(route_parameters, phantom_node_vector);
auto number_of_locations = phantom_node_vector.size(); auto number_of_locations = phantom_node_vector.size();
@ -197,58 +217,81 @@ template <class DataFacadeT> class RoundTripPlugin final : public BasePlugin
const constexpr std::size_t BF_MAX_FEASABLE = 10; const constexpr std::size_t BF_MAX_FEASABLE = 10;
BOOST_ASSERT_MSG(result_table.size() > 0, "Distance Table is empty."); BOOST_ASSERT_MSG(result_table.size() > 0, "Distance Table is empty.");
std::vector<std::vector<NodeID>> components;
//check if locations are in different strongly connected components (SCC) // get scc components
const auto maxint = INVALID_EDGE_WEIGHT; SCC_Component scc = [&](){
if (*std::max_element(result_table.begin(), result_table.end()) == maxint) { if (*std::max_element(result_table.begin(), result_table.end()) == INVALID_EDGE_WEIGHT) {
// Compute all SCC // compute all scc with tarjan
SplitUnaccessibleLocations(number_of_locations, result_table, components); return SplitUnaccessibleLocations(number_of_locations, result_table);
} else { } else {
// fill a vector with node ids // whole graph is one scc
std::vector<NodeID> location_ids(number_of_locations); std::vector<NodeID> location_ids(number_of_locations);
std::iota(std::begin(location_ids), std::end(location_ids), 0); std::iota(std::begin(location_ids), std::end(location_ids), 0);
components.push_back(std::move(location_ids)); return SCC_Component(location_ids);
} }
}();
using NodeIDIterator = typename std::vector<NodeID>::const_iterator;
std::vector<std::vector<NodeID>> res_route; std::vector<std::vector<NodeID>> res_route;
TIMER_START(tsp); TIMER_START(tsp);
//run TSP computation for every SCC //run TSP computation for every SCC
for(auto k = 0; k < components.size(); ++k) { for(auto k = 0; k < scc.GetNumberOfComponents(); ++k) {
if (components[k].size() > 1) { const auto component_size = scc.component_range[k+1] - scc.component_range[k];
if (component_size > 1) {
std::vector<NodeID> scc_route; std::vector<NodeID> scc_route;
NodeIDIterator start = std::begin(scc.component) + scc.component_range[k];
NodeIDIterator end = std::begin(scc.component) + scc.component_range[k+1];
// Compute the TSP with the given algorithm // Compute the TSP with the given algorithm
if (route_parameters.tsp_algo == "BF" && route_parameters.coordinates.size() < BF_MAX_FEASABLE) { if (route_parameters.tsp_algo == "BF" && route_parameters.coordinates.size() < BF_MAX_FEASABLE) {
SimpleLogger().Write() << "Running brute force"; SimpleLogger().Write() << "Running brute force";
scc_route = osrm::tsp::BruteForceTSP(components[k], number_of_locations, result_table); scc_route = osrm::tsp::BruteForceTSP(start, end, number_of_locations, result_table);
res_route.push_back(scc_route); res_route.push_back(scc_route);
} else if (route_parameters.tsp_algo == "NN") { } else if (route_parameters.tsp_algo == "NN") {
SimpleLogger().Write() << "Running nearest neighbour"; SimpleLogger().Write() << "Running nearest neighbour";
scc_route = osrm::tsp::NearestNeighbourTSP(components[k], number_of_locations, result_table); scc_route = osrm::tsp::NearestNeighbourTSP(start, end, number_of_locations, result_table);
res_route.push_back(scc_route); res_route.push_back(scc_route);
} else if (route_parameters.tsp_algo == "FI") { } else if (route_parameters.tsp_algo == "FI") {
SimpleLogger().Write() << "Running farthest insertion"; SimpleLogger().Write() << "Running farthest insertion";
scc_route = osrm::tsp::FarthestInsertionTSP(components[k], number_of_locations, result_table); scc_route = osrm::tsp::FarthestInsertionTSP(start, end, number_of_locations, result_table);
res_route.push_back(scc_route); res_route.push_back(scc_route);
} else{ } else{
SimpleLogger().Write() << "Running farthest insertion"; SimpleLogger().Write() << "Running farthest insertion";
scc_route = osrm::tsp::FarthestInsertionTSP(components[k], number_of_locations, result_table); scc_route = osrm::tsp::FarthestInsertionTSP(start, end, number_of_locations, result_table);
res_route.push_back(scc_route); res_route.push_back(scc_route);
} }
}
}
std::vector<InternalRouteResult> route;
ComputeRoute(phantom_node_vector, route_parameters, res_route, route);
TIMER_STOP(tsp);
SetRuntimeOutput(TIMER_MSEC(tsp), json_result);
SimpleLogger().Write() << "Computed roundtrip in " << TIMER_MSEC(tsp) << "ms";
SimpleLogger().Write() << "Route #"
<< k << ": "
<< [&scc_route](){
std::string s = "";
for (auto x : scc_route) {
s += std::to_string(x) + " ";
}
return s;
}();
}
}
std::vector<InternalRouteResult> comp_route (res_route.size());
for (auto r = 0; r < res_route.size(); ++r) {
ComputeRoute(phantom_node_vector, route_parameters, res_route[r], comp_route[r]);
}
TIMER_STOP(tsp);
SetRuntimeOutput(TIMER_MSEC(tsp), json_result);
//TODO
SetLocPermutationOutput(res_route[0], json_result);
std::unique_ptr<BaseDescriptor<DataFacadeT>> descriptor;
descriptor = osrm::make_unique<JSONDescriptor<DataFacadeT>>(facade);
descriptor->SetConfig(route_parameters);
auto dist = 0; auto dist = 0;
for (auto curr_route : route) { for (auto r : comp_route) {
dist += curr_route.shortest_path_length; dist += r.shortest_path_length;
SetGeometry(route_parameters, curr_route, json_result); // SetGeometry(route_parameters, r, json_result);
descriptor->Run(r, json_result);
} }
SetDistanceOutput(dist, json_result); SetDistanceOutput(dist, json_result);

28
routing_algorithms/tsp_brute_force.hpp
View File

@ -52,42 +52,44 @@ namespace osrm
namespace tsp namespace tsp
{ {
template <typename number> EdgeWeight ReturnDistance(const DistTableWrapper<EdgeWeight> & dist_table,
int ReturnDistance(const DistTableWrapper<EdgeWeight> & dist_table, const std::vector<NodeID> & location_order,
const std::vector<number> & location_order,
const EdgeWeight min_route_dist, const EdgeWeight min_route_dist,
const std::size_t number_of_locations) { const std::size_t component_size) {
EdgeWeight route_dist = 0; EdgeWeight route_dist = 0;
int i = 0; std::size_t i = 0;
while (i < location_order.size()) { while (i < location_order.size()) {
route_dist += dist_table(location_order[i], location_order[(i+1) % number_of_locations]); route_dist += dist_table(location_order[i], location_order[(i+1) % component_size]);
++i; ++i;
} }
return route_dist; return route_dist;
} }
std::vector<NodeID> BruteForceTSP(std::vector<NodeID> & component, template <typename NodeIDIterator>
std::vector<NodeID> BruteForceTSP(const NodeIDIterator start,
const NodeIDIterator end,
const std::size_t number_of_locations, const std::size_t number_of_locations,
const DistTableWrapper<EdgeWeight> & dist_table) { const DistTableWrapper<EdgeWeight> & dist_table) {
const auto component_size = std::distance(start, end);
std::vector<NodeID> perm(start, end);
std::vector<NodeID> route; std::vector<NodeID> route;
route.reserve(number_of_locations); route.reserve(component_size);
EdgeWeight min_route_dist = INVALID_EDGE_WEIGHT; EdgeWeight min_route_dist = INVALID_EDGE_WEIGHT;
// check length of all possible permutation of the component ids // check length of all possible permutation of the component ids
do { do {
const auto new_distance = ReturnDistance(dist_table, component, min_route_dist, number_of_locations); const auto new_distance = ReturnDistance(dist_table, perm, min_route_dist, component_size);
if (new_distance <= min_route_dist) { if (new_distance <= min_route_dist) {
min_route_dist = new_distance; min_route_dist = new_distance;
route = component; route = perm;
} }
} while(std::next_permutation(std::begin(component), std::end(component))); } while(std::next_permutation(std::begin(perm), std::end(perm)));
return route; return route;
} }
} //end namespace osrm
} //end namespace tsp } //end namespace tsp
} //end namespace osrm
#endif // TSP_BRUTE_FORCE_HPP #endif // TSP_BRUTE_FORCE_HPP

106
routing_algorithms/tsp_farthest_insertion.hpp
View File

@ -50,17 +50,16 @@ namespace osrm
namespace tsp namespace tsp
{ {
using NodeIterator = typename std::vector<NodeID>::iterator;
// given a route and a new location, find the best place of insertion and // given a route and a new location, find the best place of insertion and
// check the distance of roundtrip when the new location is additionally visited // check the distance of roundtrip when the new location is additionally visited
std::pair<EdgeWeight, NodeIterator> GetShortestRoundTrip(const int new_loc, using NodeIDIter = typename std::vector<NodeID>::iterator;
std::pair<EdgeWeight, NodeIDIter> GetShortestRoundTrip(const NodeID new_loc,
const DistTableWrapper<EdgeWeight> & dist_table, const DistTableWrapper<EdgeWeight> & dist_table,
const int number_of_locations, const std::size_t number_of_locations,
std::vector<NodeID> & route){ std::vector<NodeID> & route){
auto min_trip_distance = INVALID_EDGE_WEIGHT; auto min_trip_distance = INVALID_EDGE_WEIGHT;
NodeIterator next_insert_point_candidate; NodeIDIter next_insert_point_candidate;
// for all nodes in the current trip find the best insertion resulting in the shortest path // for all nodes in the current trip find the best insertion resulting in the shortest path
// assert min 2 nodes in route // assert min 2 nodes in route
@ -84,10 +83,12 @@ std::pair<EdgeWeight, NodeIterator> GetShortestRoundTrip(const int new_loc,
return std::make_pair(min_trip_distance, next_insert_point_candidate); return std::make_pair(min_trip_distance, next_insert_point_candidate);
} }
template <typename NodeIDIterator>
// given two initial start nodes, find a roundtrip route using the farthest insertion algorithm // given two initial start nodes, find a roundtrip route using the farthest insertion algorithm
std::vector<NodeID> FindRoute(const std::size_t & number_of_locations, std::vector<NodeID> FindRoute(const std::size_t & number_of_locations,
const std::size_t & size_of_component, const std::size_t & size_of_component,
const std::vector<NodeID> & locations, const NodeIDIterator & start,
const NodeIDIterator & end,
const DistTableWrapper<EdgeWeight> & dist_table, const DistTableWrapper<EdgeWeight> & dist_table,
const NodeID & start1, const NodeID & start1,
const NodeID & start2) { const NodeID & start2) {
@ -103,22 +104,22 @@ std::vector<NodeID> FindRoute(const std::size_t & number_of_locations,
route.push_back(start2); route.push_back(start2);
// add all other nodes missing (two nodes are already in the initial start trip) // add all other nodes missing (two nodes are already in the initial start trip)
for (int j = 2; j < size_of_component; ++j) { for (std::size_t j = 2; j < size_of_component; ++j) {
auto farthest_distance = 0; auto farthest_distance = 0;
auto next_node = -1; auto next_node = -1;
NodeIterator next_insert_point; NodeIDIter next_insert_point;
// find unvisited loc i that is the farthest away from all other visited locs // find unvisited loc i that is the farthest away from all other visited locs
for (auto i : locations) { for (auto i = start; i != end; ++i) {
// find the shortest distance from i to all visited nodes // find the shortest distance from i to all visited nodes
if (!visited[i]) { if (!visited[*i]) {
auto insert_candidate = GetShortestRoundTrip(i, dist_table, number_of_locations, route); auto insert_candidate = GetShortestRoundTrip(*i, dist_table, number_of_locations, route);
// add the location to the current trip such that it results in the shortest total tour // add the location to the current trip such that it results in the shortest total tour
if (insert_candidate.first >= farthest_distance) { if (insert_candidate.first >= farthest_distance) {
farthest_distance = insert_candidate.first; farthest_distance = insert_candidate.first;
next_node = i; next_node = *i;
next_insert_point = insert_candidate.second; next_insert_point = insert_candidate.second;
} }
} }
@ -131,7 +132,9 @@ std::vector<NodeID> FindRoute(const std::size_t & number_of_locations,
return route; return route;
} }
std::vector<NodeID> FarthestInsertionTSP(const std::vector<NodeID> & locations, template <typename NodeIDIterator>
std::vector<NodeID> FarthestInsertionTSP(const NodeIDIterator & start,
const NodeIDIterator & end,
const std::size_t number_of_locations, const std::size_t number_of_locations,
const DistTableWrapper<EdgeWeight> & dist_table) { const DistTableWrapper<EdgeWeight> & dist_table) {
////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////
@ -143,92 +146,35 @@ std::vector<NodeID> FarthestInsertionTSP(const std::vector<NodeID> & locations,
// 5. DONE! // 5. DONE!
////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////
const auto size_of_component = locations.size(); const auto component_size = std::distance(start, end);
auto max_from = -1; auto max_from = -1;
auto max_to = -1; auto max_to = -1;
if (size_of_component == number_of_locations) { if (component_size == number_of_locations) {
// find the pair of location with the biggest distance and make the pair the initial start trip // find the pair of location with the biggest distance and make the pair the initial start trip
const auto index = std::distance(dist_table.begin(), std::max_element(dist_table.begin(), dist_table.end())); const auto index = std::distance(std::begin(dist_table), std::max_element(std::begin(dist_table), std::end(dist_table)));
max_from = index / number_of_locations; max_from = index / number_of_locations;
max_to = index % number_of_locations; max_to = index % number_of_locations;
} else { } else {
auto max_dist = 0; auto max_dist = 0;
for (auto x : locations) { for (auto x = start; x != end; ++x) {
for (auto y : locations) { for (auto y = start; y != end; ++y) {
auto xy_dist = dist_table(x, y); const auto xy_dist = dist_table(*x, *y);
if (xy_dist > max_dist) { if (xy_dist > max_dist) {
max_dist = xy_dist; max_dist = xy_dist;
max_from = x; max_from = *x;
max_to = y; max_to = *y;
} }
} }
} }
} }
return FindRoute(number_of_locations, size_of_component, locations, dist_table, max_from, max_to); return FindRoute(number_of_locations, component_size, start, end, dist_table, max_from, max_to);
} }
// std::vector<NodeID> FarthestInsertionTSP(const std::size_t number_of_locations,
// const std::vector<EdgeWeight> & dist_table) {
// //////////////////////////////////////////////////////////////////////////////////////////////////
// // START FARTHEST INSERTION HERE
// // 1. start at a random round trip of 2 locations
// // 2. find the location that is the farthest away from the visited locations and whose insertion will make the round trip the longest
// // 3. add the found location to the current round trip such that round trip is the shortest
// // 4. repeat 2-3 until all locations are visited
// // 5. DONE!
// //////////////////////////////////////////////////////////////////////////////////////////////////
// std::vector<NodeID> route;
// route.reserve(number_of_locations);
// // tracks which nodes have been already visited
// std::vector<bool> visited(number_of_locations, false);
// // find the pair of location with the biggest distance and make the pair the initial start trip
// const auto index = std::distance(dist_table.begin(), std::max_element(dist_table.begin(), dist_table.end()));
// const int max_from = index / number_of_locations;
// const int max_to = index % number_of_locations;
// visited[max_from] = true;
// visited[max_to] = true;
// route.push_back(max_from);
// route.push_back(max_to);
// // add all other nodes missing (two nodes are already in the initial start trip)
// for (int j = 2; j < number_of_locations; ++j) {
// auto farthest_distance = 0;
// auto next_node = -1;
// //todo move out of loop and overwrite
// NodeIterator next_insert_point;
// // find unvisited loc i that is the farthest away from all other visited locs
// for (int i = 0; i < number_of_locations; ++i) {
// if (!visited[i]) {
// auto min_trip_distance = INVALID_EDGE_WEIGHT;
// NodeIterator next_insert_point_candidate;
// GetShortestRoundTrip(i, dist_table, number_of_locations, route, min_trip_distance, next_insert_point_candidate);
// // add the location to the current trip such that it results in the shortest total tour
// if (min_trip_distance >= farthest_distance) {
// farthest_distance = min_trip_distance;
// next_node = i;
// next_insert_point = next_insert_point_candidate;
// }
// }
// }
// // mark as visited and insert node
// visited[next_node] = true;
// route.insert(next_insert_point, next_node);
// }
// return route;
// }
} //end namespace osrm
} //end namespace tsp } //end namespace tsp
} //end namespace osrm
#endif // TSP_FARTHEST_INSERTION_HPP #endif // TSP_FARTHEST_INSERTION_HPP

37
routing_algorithms/tsp_nearest_neighbour.hpp
View File

@ -48,8 +48,9 @@ namespace osrm
{ {
namespace tsp namespace tsp
{ {
template <typename NodeIDIterator>
std::vector<NodeID> NearestNeighbourTSP(const std::vector<NodeID> & locations, std::vector<NodeID> NearestNeighbourTSP(const NodeIDIterator & start,
const NodeIDIterator & end,
const std::size_t number_of_locations, const std::size_t number_of_locations,
const DistTableWrapper<EdgeWeight> & dist_table) { const DistTableWrapper<EdgeWeight> & dist_table) {
////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////
@ -65,36 +66,36 @@ std::vector<NodeID> NearestNeighbourTSP(const std::vector<NodeID> & locations,
std::vector<NodeID> route; std::vector<NodeID> route;
route.reserve(number_of_locations); route.reserve(number_of_locations);
const int component_size = locations.size(); const auto component_size = std::distance(start, end);
int shortest_trip_distance = INVALID_EDGE_WEIGHT; auto shortest_trip_distance = INVALID_EDGE_WEIGHT;
// ALWAYS START AT ANOTHER STARTING POINT // ALWAYS START AT ANOTHER STARTING POINT
for(auto start_node : locations) for(auto start_node = start; start_node != end; ++start_node)
{ {
int curr_node = start_node; NodeID curr_node = *start_node;
std::vector<NodeID> curr_route; std::vector<NodeID> curr_route;
curr_route.reserve(component_size); curr_route.reserve(component_size);
curr_route.push_back(start_node); curr_route.push_back(*start_node);
// visited[i] indicates whether node i was already visited by the salesman // visited[i] indicates whether node i was already visited by the salesman
std::vector<bool> visited(number_of_locations, false); std::vector<bool> visited(number_of_locations, false);
visited[start_node] = true; visited[*start_node] = true;
// 3. REPEAT FOR EVERY UNVISITED NODE // 3. REPEAT FOR EVERY UNVISITED NODE
int trip_dist = 0; EdgeWeight trip_dist = 0;
for(int via_point = 1; via_point < component_size; ++via_point) for(auto via_point = 1; via_point < component_size; ++via_point)
{ {
int min_dist = INVALID_EDGE_WEIGHT; EdgeWeight min_dist = INVALID_EDGE_WEIGHT;
int min_id = -1; NodeID min_id = SPECIAL_NODEID;
// 2. FIND NEAREST NEIGHBOUR // 2. FIND NEAREST NEIGHBOUR
for (auto next : locations) { for (auto next = start; next != end; ++next) {
auto curr_dist = dist_table(curr_node, next); auto curr_dist = dist_table(curr_node, *next);
if(!visited[next] && if(!visited[*next] &&
curr_dist < min_dist) { curr_dist < min_dist) {
min_dist = curr_dist; min_dist = curr_dist;
min_id = next; min_id = *next;
} }
} }
visited[min_id] = true; visited[min_id] = true;
@ -112,6 +113,6 @@ std::vector<NodeID> NearestNeighbourTSP(const std::vector<NodeID> & locations,
return route; return route;
} }
} } //end namespace tsp
} } //end namespace osrm
#endif // TSP_NEAREST_NEIGHBOUR_HPP #endif // TSP_NEAREST_NEIGHBOUR_HPP