/* -*- 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_GREEDY_TSP_H

 #define LEMON_GREEDY_TSP_H

 /// \ingroup tsp

 /// \file

 /// \brief Greedy algorithm for symmetric TSP

 #include <vector>

 #include <algorithm>

 #include <lemon/full_graph.h>

 #include <lemon/unionfind.h>

 namespace lemon {

   /// \ingroup tsp

   ///

   /// \brief Greedy algorithm for symmetric TSP.

   ///

   /// GreedyTsp implements the greedy heuristic for solving

   /// symmetric \ref tsp "TSP".

   ///

   /// This algorithm is quite similar to the \ref NearestNeighborTsp

   /// "nearest neighbor" heuristic, but it maintains a set of disjoint paths.

   /// At each step, the shortest possible edge is added to these paths

   /// as long as it does not create a cycle of less than n edges and it does

   /// not increase the degree of any node above two.

   ///

   /// This method runs in O(n<sup>2</sup>) time.

   /// It quickly finds a relatively short tour for most TSP instances,

   /// but it could also yield a really bad (or even the worst) solution

   /// in special cases.

   ///

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

   template <typename CM>

   class GreedyTsp

   {

     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;

       Cost _sum;

       std::vector<Node> _path;

     private:

       // Functor class to compare edges by their costs

       class EdgeComp {

       private:

         const CostMap &_cost;

       public:

         EdgeComp(const CostMap &cost) : _cost(cost) {}

         bool operator()(const Edge &a, const Edge &b) const {

           return _cost[a] < _cost[b];

         }

       };

     public:

       /// \brief Constructor

       ///

       /// Constructor.

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

       /// \param cost The cost map.

       GreedyTsp(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;

         }

         std::vector<int> plist;

         plist.resize(_gr.nodeNum()*2, -1);

         std::vector<Edge> sorted_edges;

         sorted_edges.reserve(_gr.edgeNum());

         for (EdgeIt e(_gr); e != INVALID; ++e)

           sorted_edges.push_back(e);

         std::sort(sorted_edges.begin(), sorted_edges.end(), EdgeComp(_cost));

         FullGraph::NodeMap<int> item_int_map(_gr);

         UnionFind<FullGraph::NodeMap<int> > union_find(item_int_map);

         for (NodeIt n(_gr); n != INVALID; ++n)

           union_find.insert(n);

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

         int nodesNum = 0, i = 0;

         while (nodesNum != _gr.nodeNum()-1) {

           Edge e = sorted_edges[i++];

           Node u = _gr.u(e),

                v = _gr.v(e);

           if (degree[u] <= 1 && degree[v] <= 1) {

             if (union_find.join(u, v)) {

               const int uid = _gr.id(u),

                         vid = _gr.id(v);

               plist[uid*2 + degree[u]] = vid;

               plist[vid*2 + degree[v]] = uid;

               ++degree[u];

               ++degree[v];

               ++nodesNum;

             }

           }

         }

         for (int i=0, n=-1; i<_gr.nodeNum()*2; ++i) {

           if (plist[i] == -1) {

             if (n==-1) {

               n = i;

             } else {

               plist[n] = i/2;

               plist[i] = n/2;

               break;

             }

           }

         }

         for (int i=0, next=0, last=-1; i!=_gr.nodeNum(); ++i) {

           _path.push_back(_gr.nodeFromId(next));

           if (plist[2*next] != last) {

             last = next;

             next = plist[2*next];

           } else {

             last = next;

             next = plist[2*next+1];

           }

         }

         _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