/* -*- mode: C++; indent-tabs-mode: nil; -*-

  *

  * This file is a part of LEMON, a generic C++ optimization library.

  *

  * Copyright (C) 2003-2013

  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

  * (Egervary Research Group on Combinatorial Optimization, EGRES).

  *

  * Permission to use, modify and distribute this software is granted

  * provided that this copyright notice appears in all copies. For

  * precise terms see the accompanying LICENSE file.

  *

  * This software is provided "AS IS" with no warranty of any kind,

  * express or implied, and with no claim as to its suitability for any

  * purpose.

  *

  */

 #ifndef LEMON_CHRISTOFIDES_TSP_H

 #define LEMON_CHRISTOFIDES_TSP_H

 /// \ingroup tsp

 /// \file

 /// \brief Christofides algorithm for symmetric TSP

 #include <lemon/full_graph.h>

 #include <lemon/smart_graph.h>

 #include <lemon/kruskal.h>

 #include <lemon/matching.h>

 #include <lemon/euler.h>

 namespace lemon {

   /// \ingroup tsp

   ///

   /// \brief Christofides algorithm for symmetric TSP.

   ///

   /// ChristofidesTsp implements Christofides' heuristic for solving

   /// symmetric \ref tsp "TSP".

   ///

   /// This a well-known approximation method for the TSP problem with

   /// metric cost function.

   /// It has a guaranteed approximation factor of 3/2 (i.e. it finds a tour

   /// whose total cost is at most 3/2 of the optimum), but it usually

   /// provides better solutions in practice.

   /// This implementation runs in O(n<sup>3</sup>log(n)) time.

   ///

   /// The algorithm starts with a \ref spantree "minimum cost spanning tree" and

   /// finds a \ref MaxWeightedPerfectMatching "minimum cost perfect matching"

   /// in the subgraph induced by the nodes that have odd degree in the

   /// spanning tree.

   /// Finally, it constructs the tour from the \ref EulerIt "Euler traversal"

   /// of the union of the spanning tree and the matching.

   /// During this last step, the algorithm simply skips the visited nodes

   /// (i.e. creates shortcuts) assuming that the triangle inequality holds

   /// for the cost function.

   ///

   /// \tparam CM Type of the cost map.

   ///

   /// \warning CM::Value must be a signed number type.

   template <typename CM>

   class ChristofidesTsp

   {

     public:

       /// Type of the cost map

       typedef CM CostMap;

       /// Type of the edge costs

       typedef typename CM::Value Cost;

     private:

       GRAPH_TYPEDEFS(FullGraph);

       const FullGraph &_gr;

       const CostMap &_cost;

       std::vector<Node> _path;

       Cost _sum;

     public:

       /// \brief Constructor

       ///

       /// Constructor.

       /// \param gr The \ref FullGraph "full graph" the algorithm runs on.

       /// \param cost The cost map.

       ChristofidesTsp(const FullGraph &gr, const CostMap &cost)

         : _gr(gr), _cost(cost) {}

       /// \name Execution Control

       /// @{

       /// \brief Runs the algorithm.

       ///

       /// This function runs the algorithm.

       ///

       /// \return The total cost of the found tour.

       Cost run() {

         _path.clear();

         if (_gr.nodeNum() == 0) return _sum = 0;

         else if (_gr.nodeNum() == 1) {

           _path.push_back(_gr(0));

           return _sum = 0;

         }

         else if (_gr.nodeNum() == 2) {

           _path.push_back(_gr(0));

           _path.push_back(_gr(1));

           return _sum = 2 * _cost[_gr.edge(_gr(0), _gr(1))];

         }

         // Compute min. cost spanning tree

         std::vector<Edge> tree;

         kruskal(_gr, _cost, std::back_inserter(tree));

         FullGraph::NodeMap<int> deg(_gr, 0);

         for (int i = 0; i != int(tree.size()); ++i) {

           Edge e = tree[i];

           ++deg[_gr.u(e)];

           ++deg[_gr.v(e)];

         }

         // Copy the induced subgraph of odd nodes

         std::vector<Node> odd_nodes;

         for (NodeIt u(_gr); u != INVALID; ++u) {

           if (deg[u] % 2 == 1) odd_nodes.push_back(u);

         }

         SmartGraph sgr;

         SmartGraph::EdgeMap<Cost> scost(sgr);

         for (int i = 0; i != int(odd_nodes.size()); ++i) {

           sgr.addNode();

         }

         for (int i = 0; i != int(odd_nodes.size()); ++i) {

           for (int j = 0; j != int(odd_nodes.size()); ++j) {

             if (j == i) continue;

             SmartGraph::Edge e =

               sgr.addEdge(sgr.nodeFromId(i), sgr.nodeFromId(j));

             scost[e] = -_cost[_gr.edge(odd_nodes[i], odd_nodes[j])];

           }

         }

         // Compute min. cost perfect matching

         MaxWeightedPerfectMatching<SmartGraph, SmartGraph::EdgeMap<Cost> >

           mwpm(sgr, scost);

         mwpm.run();

         for (SmartGraph::EdgeIt e(sgr); e != INVALID; ++e) {

           if (mwpm.matching(e)) {

             tree.push_back( _gr.edge(odd_nodes[sgr.id(sgr.u(e))],

                                      odd_nodes[sgr.id(sgr.v(e))]) );

           }

         }

         // Join the spanning tree and the matching

         sgr.clear();

         for (int i = 0; i != _gr.nodeNum(); ++i) {

           sgr.addNode();

         }

         for (int i = 0; i != int(tree.size()); ++i) {

           int ui = _gr.id(_gr.u(tree[i])),

               vi = _gr.id(_gr.v(tree[i]));

           sgr.addEdge(sgr.nodeFromId(ui), sgr.nodeFromId(vi));

         }

         // Compute the tour from the Euler traversal

         SmartGraph::NodeMap<bool> visited(sgr, false);

         for (EulerIt<SmartGraph> e(sgr); e != INVALID; ++e) {

           SmartGraph::Node n = sgr.target(e);

           if (!visited[n]) {

             _path.push_back(_gr(sgr.id(n)));

             visited[n] = true;

           }

         }

         _sum = _cost[_gr.edge(_path.back(), _path.front())];

         for (int i = 0; i < int(_path.size())-1; ++i) {

           _sum += _cost[_gr.edge(_path[i], _path[i+1])];

         }

         return _sum;

       }

       /// @}

       /// \name Query Functions

       /// @{

       /// \brief The total cost of the found tour.

       ///

       /// This function returns the total cost of the found tour.

       ///

       /// \pre run() must be called before using this function.

       Cost tourCost() const {

         return _sum;

       }

       /// \brief Returns a const reference to the node sequence of the

       /// found tour.

       ///

       /// This function returns a const reference to a vector

       /// that stores the node sequence of the found tour.

       ///

       /// \pre run() must be called before using this function.

       const std::vector<Node>& tourNodes() const {

         return _path;

       }

       /// \brief Gives back the node sequence of the found tour.

       ///

       /// This function copies the node sequence of the found tour into

       /// an STL container through the given output iterator. The

       /// <tt>value_type</tt> of the container must be <tt>FullGraph::Node</tt>.

       /// For example,

       /// \code

       /// std::vector<FullGraph::Node> nodes(countNodes(graph));

       /// tsp.tourNodes(nodes.begin());

       /// \endcode

       /// or

       /// \code

       /// std::list<FullGraph::Node> nodes;

       /// tsp.tourNodes(std::back_inserter(nodes));

       /// \endcode

       ///

       /// \pre run() must be called before using this function.

       template <typename Iterator>

       void tourNodes(Iterator out) const {

         std::copy(_path.begin(), _path.end(), out);

       }

       /// \brief Gives back the found tour as a path.

       ///

       /// This function copies the found tour as a list of arcs/edges into

       /// the given \ref lemon::concepts::Path "path structure".

       ///

       /// \pre run() must be called before using this function.

       template <typename Path>

       void tour(Path &path) const {

         path.clear();

         for (int i = 0; i < int(_path.size()) - 1; ++i) {

           path.addBack(_gr.arc(_path[i], _path[i+1]));

         }

         if (int(_path.size()) >= 2) {

           path.addBack(_gr.arc(_path.back(), _path.front()));

         }

       }

       /// @}

   };

 }; // namespace lemon

 #endif