Commit 3a7ae957 authored by Tiago Peixoto's avatar Tiago Peixoto
Browse files

Implement tsp_tour()

parent 40bac497
//=======================================================================
// Copyright 2008
// Author: Matyas W Egyhazy
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
//=======================================================================
#ifndef BOOST_GRAPH_METRIC_TSP_APPROX_HPP
#define BOOST_GRAPH_METRIC_TSP_APPROX_HPP
// metric_tsp_approx
// Generates an approximate tour solution for the traveling salesperson
// problem in polynomial time. The current algorithm guarantees a tour with a
// length at most as long as 2x optimal solution. The graph should have
// 'natural' (metric) weights such that the triangle inequality is maintained.
// Graphs must be fully interconnected.
// TODO:
// There are a couple of improvements that could be made.
// 1) Change implementation to lower uppper bound Christofides heuristic
// 2) Implement a less restrictive TSP heuristic (one that does not rely on
// triangle inequality).
// 3) Determine if the algorithm can be implemented without creating a new
// graph.
#include <vector>
#include <boost/shared_ptr.hpp>
#include <boost/concept_check.hpp>
#include <boost/graph/graph_traits.hpp>
#include <boost/graph/graph_as_tree.hpp>
#include <boost/graph/adjacency_list.hpp>
#include <boost/graph/prim_minimum_spanning_tree.hpp>
#include <boost/graph/lookup_edge.hpp>
#include <boost/throw_exception.hpp>
namespace boost
{
// Define a concept for the concept-checking library.
template <typename Visitor, typename Graph>
struct TSPVertexVisitorConcept
{
private:
Visitor vis_;
public:
typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
BOOST_CONCEPT_USAGE(TSPVertexVisitorConcept)
{
Visitor vis(vis_); // require copy construction
Graph* g;
Vertex v(*vertices(*g).first);
vis_.visit_vertex(v, *g); // require visit_vertex
}
};
// Tree visitor that keeps track of a preorder traversal of a tree
// TODO: Consider migrating this to the graph_as_tree header.
// TODO: Parameterize the underlying stores o it doesn't have to be a vector.
template<typename Node, typename Tree> class PreorderTraverser
{
private:
std::vector<Node>& path_;
public:
typedef typename std::vector<Node>::const_iterator const_iterator;
PreorderTraverser(std::vector<Node>& p) : path_(p) {}
void preorder(Node n, const Tree&)
{ path_.push_back(n); }
void inorder(Node, const Tree&) const {}
void postorder(Node, const Tree&) const {}
const_iterator begin() const { return path_.begin(); }
const_iterator end() const { return path_.end(); }
};
// Forward declarations
template <typename> class tsp_tour_visitor;
template <typename, typename, typename, typename> class tsp_tour_len_visitor;
template<typename VertexListGraph, typename OutputIterator>
void metric_tsp_approx_tour(VertexListGraph& g, OutputIterator o)
{
metric_tsp_approx_from_vertex(g, *vertices(g).first,
get(edge_weight, g), get(vertex_index, g),
tsp_tour_visitor<OutputIterator>(o));
}
template<typename VertexListGraph, typename WeightMap, typename OutputIterator>
void metric_tsp_approx_tour(VertexListGraph& g, WeightMap w, OutputIterator o)
{
metric_tsp_approx_from_vertex(g, *vertices(g).first,
w, tsp_tour_visitor<OutputIterator>(o));
}
template<typename VertexListGraph, typename OutputIterator>
void metric_tsp_approx_tour_from_vertex(VertexListGraph& g,
typename graph_traits<VertexListGraph>::vertex_descriptor start,
OutputIterator o)
{
metric_tsp_approx_from_vertex(g, start, get(edge_weight, g),
get(vertex_index, g), tsp_tour_visitor<OutputIterator>(o));
}
template<typename VertexListGraph, typename WeightMap,
typename OutputIterator>
void metric_tsp_approx_tour_from_vertex(VertexListGraph& g,
typename graph_traits<VertexListGraph>::vertex_descriptor start,
WeightMap w, OutputIterator o)
{
metric_tsp_approx_from_vertex(g, start, w, get(vertex_index, g),
tsp_tour_visitor<OutputIterator>(o));
}
template<typename VertexListGraph, typename TSPVertexVisitor>
void metric_tsp_approx(VertexListGraph& g, TSPVertexVisitor vis)
{
metric_tsp_approx_from_vertex(g, *vertices(g).first,
get(edge_weight, g), get(vertex_index, g), vis);
}
template<typename VertexListGraph, typename Weightmap,
typename VertexIndexMap, typename TSPVertexVisitor>
void metric_tsp_approx(VertexListGraph& g, Weightmap w,
TSPVertexVisitor vis)
{
metric_tsp_approx_from_vertex(g, *vertices(g).first, w,
get(vertex_index, g), vis);
}
template<typename VertexListGraph, typename WeightMap,
typename VertexIndexMap, typename TSPVertexVisitor>
void metric_tsp_approx(VertexListGraph& g, WeightMap w, VertexIndexMap id,
TSPVertexVisitor vis)
{
metric_tsp_approx_from_vertex(g, *vertices(g).first, w, id, vis);
}
template<typename VertexListGraph, typename WeightMap,
typename TSPVertexVisitor>
void metric_tsp_approx_from_vertex(VertexListGraph& g,
typename graph_traits<VertexListGraph>::vertex_descriptor start,
WeightMap w, TSPVertexVisitor vis)
{
metric_tsp_approx_from_vertex(g, start, w, get(vertex_index, g), vis);
}
template <
typename VertexListGraph,
typename WeightMap,
typename VertexIndexMap,
typename TSPVertexVisitor>
void metric_tsp_approx_from_vertex(const VertexListGraph& g,
typename graph_traits<VertexListGraph>::vertex_descriptor start,
WeightMap weightmap,
VertexIndexMap indexmap,
TSPVertexVisitor vis)
{
using namespace boost;
using namespace std;
BOOST_CONCEPT_ASSERT((VertexListGraphConcept<VertexListGraph>));
BOOST_CONCEPT_ASSERT((TSPVertexVisitorConcept<TSPVertexVisitor, VertexListGraph>));
// Types related to the input graph (GVertex is a template parameter).
typedef typename graph_traits<VertexListGraph>::vertex_descriptor GVertex;
typedef typename graph_traits<VertexListGraph>::vertex_iterator GVItr;
// We build a custom graph in this algorithm.
typedef adjacency_list <vecS, vecS, directedS, no_property, no_property > MSTImpl;
typedef graph_traits<MSTImpl>::edge_descriptor Edge;
typedef graph_traits<MSTImpl>::vertex_descriptor Vertex;
typedef graph_traits<MSTImpl>::vertex_iterator VItr;
// And then re-cast it as a tree.
typedef iterator_property_map<vector<Vertex>::iterator, property_map<MSTImpl, vertex_index_t>::type> ParentMap;
typedef graph_as_tree<MSTImpl, ParentMap> Tree;
typedef tree_traits<Tree>::node_descriptor Node;
// A predecessor map.
typedef vector<GVertex> PredMap;
typedef iterator_property_map<typename PredMap::iterator, VertexIndexMap> PredPMap;
PredMap preds(num_vertices(g));
PredPMap pred_pmap(preds.begin(), indexmap);
// Compute a spanning tree over the in put g.
prim_minimum_spanning_tree(g, pred_pmap,
root_vertex(start)
.vertex_index_map(indexmap)
.weight_map(weightmap));
// Build a MST using the predecessor map from prim mst
MSTImpl mst(num_vertices(g));
std::size_t cnt = 0;
pair<VItr, VItr> mst_verts(vertices(mst));
for(typename PredMap::iterator vi(preds.begin()); vi != preds.end(); ++vi, ++cnt)
{
if(indexmap[*vi] != cnt) {
add_edge(*next(mst_verts.first, indexmap[*vi]),
*next(mst_verts.first, cnt), mst);
}
}
// Build a tree abstraction over the MST.
vector<Vertex> parent(num_vertices(mst));
Tree t(mst, *vertices(mst).first,
make_iterator_property_map(parent.begin(),
get(vertex_index, mst)));
// Create tour using a preorder traversal of the mst
vector<Node> tour;
PreorderTraverser<Node, Tree> tvis(tour);
traverse_tree(0, t, tvis);
pair<GVItr, GVItr> g_verts(vertices(g));
for(PreorderTraverser<Node, Tree>::const_iterator curr(tvis.begin());
curr != tvis.end(); ++curr)
{
// TODO: This is will be O(n^2) if vertex storage of g != vecS.
GVertex v = *next(g_verts.first, get(vertex_index, mst)[*curr]);
vis.visit_vertex(v, g);
}
// Connect back to the start of the tour
vis.visit_vertex(*g_verts.first, g);
}
// Default tsp tour visitor that puts the tour in an OutputIterator
template <typename OutItr>
class tsp_tour_visitor
{
OutItr itr_;
public:
tsp_tour_visitor(OutItr itr)
: itr_(itr)
{ }
template <typename Vertex, typename Graph>
void visit_vertex(Vertex v, const Graph&)
{
BOOST_CONCEPT_ASSERT((OutputIterator<OutItr, Vertex>));
*itr_++ = v;
}
};
// Tsp tour visitor that adds the total tour length.
template<typename Graph, typename WeightMap, typename OutIter, typename Length>
class tsp_tour_len_visitor
{
typedef typename graph_traits<Graph>::vertex_descriptor Vertex;
BOOST_CONCEPT_ASSERT((OutputIterator<OutIter, Vertex>));
OutIter iter_;
Length& tourlen_;
WeightMap& wmap_;
Vertex previous_;
// Helper function for getting the null vertex.
Vertex null()
{ return graph_traits<Graph>::null_vertex(); }
public:
tsp_tour_len_visitor(Graph const&, OutIter iter, Length& l, WeightMap map)
: iter_(iter), tourlen_(l), wmap_(map), previous_(null())
{ }
void visit_vertex(Vertex v, const Graph& g)
{
typedef typename graph_traits<Graph>::edge_descriptor Edge;
// If it is not the start, then there is a
// previous vertex
if(previous_ != null())
{
// NOTE: For non-adjacency matrix graphs g, this bit of code
// will be linear in the degree of previous_ or v. A better
// solution would be to visit edges of the graph, but that
// would require revisiting the core algorithm.
Edge e;
bool found;
boost::tie(e, found) = lookup_edge(previous_, v, g);
if(!found) {
BOOST_THROW_EXCEPTION(not_complete());
}
tourlen_ += wmap_[e];
}
previous_ = v;
*iter_++ = v;
}
};
// Object generator(s)
template <typename OutIter>
inline tsp_tour_visitor<OutIter>
make_tsp_tour_visitor(OutIter iter)
{ return tsp_tour_visitor<OutIter>(iter); }
template <typename Graph, typename WeightMap, typename OutIter, typename Length>
inline tsp_tour_len_visitor<Graph, WeightMap, OutIter, Length>
make_tsp_tour_len_visitor(Graph const& g, OutIter iter, Length& l, WeightMap map)
{ return tsp_tour_len_visitor<Graph, WeightMap, OutIter, Length>(g, iter, l, map); }
} //boost
#endif // BOOST_GRAPH_METRIC_TSP_APPROX_HPP
......@@ -32,6 +32,7 @@ libgraph_tool_topology_la_SOURCES = \
graph_subgraph_isomorphism.cc \
graph_topological_sort.cc \
graph_topology.cc \
graph_tsp.cc \
graph_transitive_closure.cc
......
// graph-tool -- a general graph modification and manipulation thingy
//
// Copyright (C) 2007-2012 Tiago de Paula Peixoto <tiago@skewed.de>
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 3
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "graph_filtering.hh"
#include "graph.hh"
#include "graph_properties.hh"
#include <boost/graph/metric_tsp_approx.hpp>
using namespace std;
using namespace boost;
using namespace graph_tool;
struct get_tsp_approx
{
template <class Graph, class WeightMap, class IntType>
void operator()(Graph& g, size_t src, WeightMap weights,
vector<IntType>& tour) const
{
back_insert_iterator<vector<IntType> > back_it(tour);
metric_tsp_approx_tour_from_vertex(g, vertex(src, g), weights,
back_it);
}
};
vector<int32_t> get_tsp(GraphInterface& gi, size_t src, boost::any weight_map)
{
vector<int32_t> tour;
typedef ConstantPropertyMap<size_t,GraphInterface::edge_t> cweight_t;
if (weight_map.empty())
weight_map = cweight_t(1);
typedef mpl::push_back<edge_scalar_properties, cweight_t>::type
weight_maps;
run_action<graph_tool::detail::never_directed>()
(gi, bind<void>(get_tsp_approx(), _1, src, _2, ref(tour)),
weight_maps())(weight_map);
return tour;
}
......@@ -42,6 +42,7 @@ Summary
dominator_tree
topological_sort
transitive_closure
tsp_tour
label_components
label_biconnected_components
label_largest_component
......@@ -66,11 +67,11 @@ import random, sys, numpy
__all__ = ["isomorphism", "subgraph_isomorphism", "mark_subgraph",
"max_cardinality_matching", "max_independent_vertex_set",
"min_spanning_tree", "random_spanning_tree", "dominator_tree",
"topological_sort", "transitive_closure", "label_components",
"label_largest_component", "label_biconnected_components",
"label_out_component", "shortest_distance", "shortest_path",
"pseudo_diameter", "is_bipartite", "is_planar", "similarity",
"edge_reciprocity"]
"topological_sort", "transitive_closure", "tsp_tour",
"label_components", "label_largest_component",
"label_biconnected_components", "label_out_component",
"shortest_distance", "shortest_path", "pseudo_diameter",
"is_bipartite", "is_planar", "similarity", "edge_reciprocity"]
def similarity(g1, g2, label1=None, label2=None, norm=True):
......@@ -1497,4 +1498,53 @@ def edge_reciprocity(g):
r = libgraph_tool_topology.reciprocity(g._Graph__graph)
return r
def tsp_tour(g, src, weight=None):
"""Return a traveling salesman tour of the graph, which is guaranteed to be
twice as long as the optimal tour in the worst case.
Parameters
----------
g : :class:`~graph_tool.Graph`
Graph to be used.
src : :class:`~graph_tool.Vertex`
The source (and target) of the tour.
weight : :class:`~graph_tool.PropertyMap` (optional, default: None)
Edge weights.
Returns
-------
tour : :class:`numpy.ndarray`
List of vertex indexes corresponding to the tour.
Notes
-----
The algorithm runs with :math:`O(E\log V)` complexity.
Examples
--------
>>> g = gt.lattice([20, 20])
>>> tour = gt.tsp_tour(g, g.vertex(0))
>>> print(tour)
[ 0 1 2 11 12 21 22 31 32 41 42 51 52 61 62 71 72 81 82 83 73 63 53 43 33
23 13 3 4 5 6 7 8 9 19 29 39 49 59 69 79 89 14 24 34 44 54 64 74 84
91 92 93 94 95 85 75 65 55 45 35 25 15 16 17 18 27 28 37 38 47 48 57 58 67
68 77 78 87 88 97 98 99 26 36 46 56 66 76 86 96 10 20 30 40 50 60 70 80 90
0]
References
----------
.. [tsp-bgl] http://www.boost.org/libs/graph/doc/metric_tsp_approx.html
.. [tsp] http://en.wikipedia.org/wiki/Travelling_salesman_problem
"""
if g.is_directed():
raise ValueError("Graph must be undirected.")
tour = libgraph_tool_topology.\
get_tsp(g._Graph__graph, int(src),
_prop("e", g, weight))
return tour.a.copy()
from .. flow import libgraph_tool_flow
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment