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

 *

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

 *

 * Copyright (C) 2003-2010

 * 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_INSERTION_TSP_H

#define LEMON_INSERTION_TSP_H

/// \ingroup tsp

/// \file

/// \brief Insertion algorithm for symmetric TSP

#include <vector>

#include <functional>

#include <lemon/full_graph.h>

#include <lemon/maps.h>

#include <lemon/random.h>

namespace lemon {

  /// \ingroup tsp

  ///

  /// \brief Insertion algorithm for symmetric TSP.

  ///

  /// InsertionTsp implements the insertion heuristic for solving

  /// symmetric \ref tsp "TSP".

  ///

  /// This is a fast and effective tour construction method that has

  /// many variants.

  /// It starts with a subtour containing a few nodes of the graph and it

  /// iteratively inserts the other nodes into this subtour according to a

  /// certain node selection rule.

  ///

  /// This method is among the fastest TSP algorithms, and it typically

  /// provides quite good solutions (usually much better than

  /// \ref NearestNeighborTsp and \ref GreedyTsp).

  ///

  /// InsertionTsp implements four different node selection rules,

  /// from which the most effective one (\e farthest \e node \e selection)

  /// is used by default.

  /// With this choice, the algorithm runs in O(n<sup>2</sup>) time.

  /// For more information, see \ref SelectionRule.

  ///

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

  template <typename CM>

  class InsertionTsp

  {

    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> _notused;

      std::vector<Node> _tour;

      Cost _sum;

    public:

      /// \brief Constants for specifying the node selection rule.

      ///

      /// Enum type containing constants for specifying the node selection

      /// rule for the \ref run() function.

      ///

      /// During the algorithm, nodes are selected for addition to the current

      /// subtour according to the applied rule.

      /// The FARTHEST method is one of the fastest selection rules, and

      /// it is typically the most effective, thus it is the default

      /// option. The RANDOM rule usually gives slightly worse results,

      /// but it is more robust.

      ///

      /// The desired selection rule can be specified as a parameter of the

      /// \ref run() function.

      enum SelectionRule {

        /// An unvisited node having minimum distance from the current

        /// subtour is selected at each step.

        /// The algorithm runs in O(n<sup>2</sup>) time using this

        /// selection rule.

        NEAREST,

        /// An unvisited node having maximum distance from the current

        /// subtour is selected at each step.

        /// The algorithm runs in O(n<sup>2</sup>) time using this

        /// selection rule.

        FARTHEST,

        /// An unvisited node whose insertion results in the least

        /// increase of the subtour's total cost is selected at each step.

        /// The algorithm runs in O(n<sup>3</sup>) time using this

        /// selection rule, but in most cases, it is almost as fast as

        /// with other rules.

        CHEAPEST,

        /// An unvisited node is selected randomly without any evaluation

        /// at each step.

        /// The global \ref rnd "random number generator instance" is used.

        /// You can seed it before executing the algorithm, if you

        /// would like to.

        /// The algorithm runs in O(n<sup>2</sup>) time using this

        /// selection rule.

        RANDOM

      };

    public:

      /// \brief Constructor

      ///

      /// Constructor.

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

      /// \param cost The cost map.

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

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

      /// \name Execution Control

      /// @{

      /// \brief Runs the algorithm.

      ///

      /// This function runs the algorithm.

      ///

      /// \param rule The node selection rule. For more information, see

      /// \ref SelectionRule.

      ///

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

      Cost run(SelectionRule rule = FARTHEST) {

        _tour.clear();

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

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

          _tour.push_back(_gr(0));

          return _sum = 0;

        }

        switch (rule) {

          case NEAREST:

            init(true);

            start<ComparingSelection<std::less<Cost> >,

                  DefaultInsertion>();

            break;

          case FARTHEST:

            init(false);

            start<ComparingSelection<std::greater<Cost> >,

                  DefaultInsertion>();

            break;

          case CHEAPEST:

            init(true);

            start<CheapestSelection, CheapestInsertion>();

            break;

          case RANDOM:

            init(true);

            start<RandomSelection, DefaultInsertion>();

            break;

        }

        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 _tour;

      }

      /// \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(_tour.begin(), _tour.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(_tour.size()) - 1; ++i) {

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

        }

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

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

        }

      }

      /// @}

    private:

      // Initializes the algorithm

      void init(bool min) {

        Edge min_edge = min ? mapMin(_gr, _cost) : mapMax(_gr, _cost);

        _tour.clear();

        _tour.push_back(_gr.u(min_edge));

        _tour.push_back(_gr.v(min_edge));

        _notused.clear();

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

          if (n != _gr.u(min_edge) && n != _gr.v(min_edge)) {

            _notused.push_back(n);

          }

        }

        _sum = _cost[min_edge] * 2;

      }

      // Executes the algorithm

      template <class SelectionFunctor, class InsertionFunctor>

      void start() {

        SelectionFunctor selectNode(_gr, _cost, _tour, _notused);

        InsertionFunctor insertNode(_gr, _cost, _tour, _sum);

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

          insertNode.insert(selectNode.select());

        }

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

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

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

        }

      }

      // Implementation of the nearest and farthest selection rule

      template <typename Comparator>

      class ComparingSelection {

        public:

          ComparingSelection(const FullGraph &gr, const CostMap &cost,

                  std::vector<Node> &tour, std::vector<Node> &notused)

            : _gr(gr), _cost(cost), _tour(tour), _notused(notused),

              _dist(gr, 0), _compare()

          {

            // Compute initial distances for the unused nodes

            for (unsigned int i=0; i<_notused.size(); ++i) {

              Node u = _notused[i];

              Cost min_dist = _cost[_gr.edge(u, _tour[0])];

              for (unsigned int j=1; j<_tour.size(); ++j) {

                Cost curr = _cost[_gr.edge(u, _tour[j])];

                if (curr < min_dist) {

                  min_dist = curr;

                }

              }

              _dist[u] = min_dist;

            }

          }

          Node select() {

            // Select an used node with minimum distance

            Cost ins_dist = 0;

            int ins_node = -1;

            for (unsigned int i=0; i<_notused.size(); ++i) {

              Cost curr = _dist[_notused[i]];

              if (_compare(curr, ins_dist) || ins_node == -1) {

                ins_dist = curr;

                ins_node = i;

              }

            }

            // Remove the selected node from the unused vector

            Node sn = _notused[ins_node];

            _notused[ins_node] = _notused.back();

            _notused.pop_back();

            // Update the distances of the remaining nodes

            for (unsigned int i=0; i<_notused.size(); ++i) {

              Node u = _notused[i];

              Cost nc = _cost[_gr.edge(sn, u)];

              if (nc < _dist[u]) {

                _dist[u] = nc;

              }

            }

            return sn;

          }

        private:

          const FullGraph &_gr;

          const CostMap &_cost;

          std::vector<Node> &_tour;

          std::vector<Node> &_notused;

          FullGraph::NodeMap<Cost> _dist;

          Comparator _compare;

      };

      // Implementation of the cheapest selection rule

      class CheapestSelection {

        private:

          Cost costDiff(Node u, Node v, Node w) const {

            return

              _cost[_gr.edge(u, w)] +

              _cost[_gr.edge(v, w)] -

              _cost[_gr.edge(u, v)];

          }

        public:

          CheapestSelection(const FullGraph &gr, const CostMap &cost,

                            std::vector<Node> &tour, std::vector<Node> &notused)

            : _gr(gr), _cost(cost), _tour(tour), _notused(notused),

              _ins_cost(gr, 0), _ins_pos(gr, -1)

          {

            // Compute insertion cost and position for the unused nodes

            for (unsigned int i=0; i<_notused.size(); ++i) {

              Node u = _notused[i];

              Cost min_cost = costDiff(_tour.back(), _tour.front(), u);

              int min_pos = 0;              

              for (unsigned int j=1; j<_tour.size(); ++j) {

                Cost curr_cost = costDiff(_tour[j-1], _tour[j], u);

                if (curr_cost < min_cost) {

                  min_cost = curr_cost;

                  min_pos = j;

                }

              }

              _ins_cost[u] = min_cost;

              _ins_pos[u] = min_pos;

            }

          }

          Cost select() {

            // Select an used node with minimum insertion cost

            Cost min_cost = 0;

            int min_node = -1;

            for (unsigned int i=0; i<_notused.size(); ++i) {

              Cost curr_cost = _ins_cost[_notused[i]];

              if (curr_cost < min_cost || min_node == -1) {

                min_cost = curr_cost;

                min_node = i;

              }

            }

            // Remove the selected node from the unused vector

            Node sn = _notused[min_node];

            _notused[min_node] = _notused.back();

            _notused.pop_back();

            // Insert the selected node into the tour

            const int ipos = _ins_pos[sn];

            _tour.insert(_tour.begin() + ipos, sn);

            // Update the insertion cost and position of the remaining nodes

            for (unsigned int i=0; i<_notused.size(); ++i) {

              Node u = _notused[i];

              Cost curr_cost = _ins_cost[u];

              int curr_pos = _ins_pos[u];

              int ipos_prev = ipos == 0 ? _tour.size()-1 : ipos-1;

              int ipos_next = ipos == int(_tour.size())-1 ? 0 : ipos+1;

              Cost nc1 = costDiff(_tour[ipos_prev], _tour[ipos], u);

              Cost nc2 = costDiff(_tour[ipos], _tour[ipos_next], u);

              if (nc1 <= curr_cost || nc2 <= curr_cost) {

                // A new position is better than the old one

                if (nc1 <= nc2) {

                  curr_cost = nc1;

                  curr_pos = ipos;

                } else {

                  curr_cost = nc2;

                  curr_pos = ipos_next;

                }

              }

              else {

                if (curr_pos == ipos) {

                  // The minimum should be found again

                  curr_cost = costDiff(_tour.back(), _tour.front(), u);

                  curr_pos = 0;              

                  for (unsigned int j=1; j<_tour.size(); ++j) {

                    Cost tmp_cost = costDiff(_tour[j-1], _tour[j], u);

                    if (tmp_cost < curr_cost) {

                      curr_cost = tmp_cost;

                      curr_pos = j;

                    }

                  }

                }

                else if (curr_pos > ipos) {

                  ++curr_pos;

                }

              }

              _ins_cost[u] = curr_cost;

              _ins_pos[u] = curr_pos;

            }

            return min_cost;

          }

        private:

          const FullGraph &_gr;

          const CostMap &_cost;

          std::vector<Node> &_tour;

          std::vector<Node> &_notused;

          FullGraph::NodeMap<Cost> _ins_cost;

          FullGraph::NodeMap<int> _ins_pos;

      };

      // Implementation of the random selection rule

      class RandomSelection {

        public:

          RandomSelection(const FullGraph &, const CostMap &,

                          std::vector<Node> &, std::vector<Node> &notused)

            : _notused(notused) {}

          Node select() const {

            const int index = rnd[_notused.size()];

            Node n = _notused[index];

            _notused[index] = _notused.back();

            _notused.pop_back();

            return n;

          }

        private:

          std::vector<Node> &_notused;

      };

      // Implementation of the default insertion method

      class DefaultInsertion {

        private:

          Cost costDiff(Node u, Node v, Node w) const {

            return

              _cost[_gr.edge(u, w)] +

              _cost[_gr.edge(v, w)] -

              _cost[_gr.edge(u, v)];

          }

        public:

          DefaultInsertion(const FullGraph &gr, const CostMap &cost,

                           std::vector<Node> &tour, Cost &total_cost) :

            _gr(gr), _cost(cost), _tour(tour), _total(total_cost) {}

          void insert(Node n) const {

            int min = 0;

            Cost min_val =

              costDiff(_tour.front(), _tour.back(), n);

            for (unsigned int i=1; i<_tour.size(); ++i) {

              Cost tmp = costDiff(_tour[i-1], _tour[i], n);

              if (tmp < min_val) {

                min = i;

                min_val = tmp;

              }

            }

            _tour.insert(_tour.begin()+min, n);

            _total += min_val;

          }

        private:

          const FullGraph &_gr;

          const CostMap &_cost;

          std::vector<Node> &_tour;

          Cost &_total;

      };

      // Implementation of a special insertion method for the cheapest

      // selection rule

      class CheapestInsertion {

        TEMPLATE_GRAPH_TYPEDEFS(FullGraph);

        public:

          CheapestInsertion(const FullGraph &, const CostMap &,

                            std::vector<Node> &, Cost &total_cost) :

            _total(total_cost) {}

          void insert(Cost diff) const {

            _total += diff;

          }

        private:

          Cost &_total;

      };

  };

}; // namespace lemon

#endif