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

 #define LEMON_STATIC_GRAPH_H

 ///\ingroup graphs

 ///\file

 ///\brief StaticDigraph class.

 #include <lemon/core.h>

 #include <lemon/bits/graph_extender.h>

 namespace lemon {

   class StaticDigraphBase {

   public:

     StaticDigraphBase()

       : built(false), node_num(0), arc_num(0),

         node_first_out(NULL), node_first_in(NULL),

         arc_source(NULL), arc_target(NULL),

         arc_next_in(NULL), arc_next_out(NULL) {}

     ~StaticDigraphBase() {

       if (built) {

         delete[] node_first_out;

         delete[] node_first_in;

         delete[] arc_source;

         delete[] arc_target;

         delete[] arc_next_out;

         delete[] arc_next_in;

       }

     }

     class Node {

       friend class StaticDigraphBase;

     protected:

       int id;

       Node(int _id) : id(_id) {}

     public:

       Node() {}

       Node (Invalid) : id(-1) {}

       bool operator==(const Node& node) const { return id == node.id; }

       bool operator!=(const Node& node) const { return id != node.id; }

       bool operator<(const Node& node) const { return id < node.id; }

     };

     class Arc {

       friend class StaticDigraphBase;

     protected:

       int id;

       Arc(int _id) : id(_id) {}

     public:

       Arc() { }

       Arc (Invalid) : id(-1) {}

       bool operator==(const Arc& arc) const { return id == arc.id; }

       bool operator!=(const Arc& arc) const { return id != arc.id; }

       bool operator<(const Arc& arc) const { return id < arc.id; }

     };

     Node source(const Arc& e) const { return Node(arc_source[e.id]); }

     Node target(const Arc& e) const { return Node(arc_target[e.id]); }

     void first(Node& n) const { n.id = node_num - 1; }

     static void next(Node& n) { --n.id; }

     void first(Arc& e) const { e.id = arc_num - 1; }

     static void next(Arc& e) { --e.id; }

     void firstOut(Arc& e, const Node& n) const {

       e.id = node_first_out[n.id] != node_first_out[n.id + 1] ?

         node_first_out[n.id] : -1;

     }

     void nextOut(Arc& e) const { e.id = arc_next_out[e.id]; }

     void firstIn(Arc& e, const Node& n) const { e.id = node_first_in[n.id]; }

     void nextIn(Arc& e) const { e.id = arc_next_in[e.id]; }

     static int id(const Node& n) { return n.id; }

     static Node nodeFromId(int id) { return Node(id); }

     int maxNodeId() const { return node_num - 1; }

     static int id(const Arc& e) { return e.id; }

     static Arc arcFromId(int id) { return Arc(id); }

     int maxArcId() const { return arc_num - 1; }

     typedef True NodeNumTag;

     typedef True ArcNumTag;

     int nodeNum() const { return node_num; }

     int arcNum() const { return arc_num; }

   private:

     template <typename Digraph, typename NodeRefMap>

     class ArcLess {

     public:

       typedef typename Digraph::Arc Arc;

       ArcLess(const Digraph &_graph, const NodeRefMap& _nodeRef)

         : digraph(_graph), nodeRef(_nodeRef) {}

       bool operator()(const Arc& left, const Arc& right) const {

         return nodeRef[digraph.target(left)] < nodeRef[digraph.target(right)];

       }

     private:

       const Digraph& digraph;

       const NodeRefMap& nodeRef;

     };

   public:

     typedef True BuildTag;

     void clear() {

       if (built) {

         delete[] node_first_out;

         delete[] node_first_in;

         delete[] arc_source;

         delete[] arc_target;

         delete[] arc_next_out;

         delete[] arc_next_in;

       }

       built = false;

       node_num = 0;

       arc_num = 0;

     }

     template <typename Digraph, typename NodeRefMap, typename ArcRefMap>

     void build(const Digraph& digraph, NodeRefMap& nodeRef, ArcRefMap& arcRef) {

       typedef typename Digraph::Node GNode;

       typedef typename Digraph::Arc GArc;

       built = true;

       node_num = countNodes(digraph);

       arc_num = countArcs(digraph);

       node_first_out = new int[node_num + 1];

       node_first_in = new int[node_num];

       arc_source = new int[arc_num];

       arc_target = new int[arc_num];

       arc_next_out = new int[arc_num];

       arc_next_in = new int[arc_num];

       int node_index = 0;

       for (typename Digraph::NodeIt n(digraph); n != INVALID; ++n) {

         nodeRef[n] = Node(node_index);

         node_first_in[node_index] = -1;

         ++node_index;

       }

       ArcLess<Digraph, NodeRefMap> arcLess(digraph, nodeRef);

       int arc_index = 0;

       for (typename Digraph::NodeIt n(digraph); n != INVALID; ++n) {

         int source = nodeRef[n].id;

         std::vector<GArc> arcs;

         for (typename Digraph::OutArcIt e(digraph, n); e != INVALID; ++e) {

           arcs.push_back(e);

         }

         if (!arcs.empty()) {

           node_first_out[source] = arc_index;

           std::sort(arcs.begin(), arcs.end(), arcLess);

           for (typename std::vector<GArc>::iterator it = arcs.begin();

                it != arcs.end(); ++it) {

             int target = nodeRef[digraph.target(*it)].id;

             arcRef[*it] = Arc(arc_index);

             arc_source[arc_index] = source;

             arc_target[arc_index] = target;

             arc_next_in[arc_index] = node_first_in[target];

             node_first_in[target] = arc_index;

             arc_next_out[arc_index] = arc_index + 1;

             ++arc_index;

           }

           arc_next_out[arc_index - 1] = -1;

         } else {

           node_first_out[source] = arc_index;

         }

       }

       node_first_out[node_num] = arc_num;

     }

     template <typename ArcListIterator>

     void build(int n, ArcListIterator first, ArcListIterator last) {

       built = true;

       node_num = n;

       arc_num = std::distance(first, last);

       node_first_out = new int[node_num + 1];

       node_first_in = new int[node_num];

       arc_source = new int[arc_num];

       arc_target = new int[arc_num];

       arc_next_out = new int[arc_num];

       arc_next_in = new int[arc_num];

       for (int i = 0; i != node_num; ++i) {

         node_first_in[i] = -1;

       }

       int arc_index = 0;

       for (int i = 0; i != node_num; ++i) {

         node_first_out[i] = arc_index;

         for ( ; first != last && (*first).first == i; ++first) {

           int j = (*first).second;

           LEMON_ASSERT(j >= 0 && j < node_num,

             "Wrong arc list for StaticDigraph::build()");

           arc_source[arc_index] = i;

           arc_target[arc_index] = j;

           arc_next_in[arc_index] = node_first_in[j];

           node_first_in[j] = arc_index;

           arc_next_out[arc_index] = arc_index + 1;

           ++arc_index;

         }

         if (arc_index > node_first_out[i])

           arc_next_out[arc_index - 1] = -1;

       }

       LEMON_ASSERT(first == last,

         "Wrong arc list for StaticDigraph::build()");

       node_first_out[node_num] = arc_num;

     }

   protected:

     void fastFirstOut(Arc& e, const Node& n) const {

       e.id = node_first_out[n.id];

     }

     static void fastNextOut(Arc& e) {

       ++e.id;

     }

     void fastLastOut(Arc& e, const Node& n) const {

       e.id = node_first_out[n.id + 1];

     }

   protected:

     bool built;

     int node_num;

     int arc_num;

     int *node_first_out;

     int *node_first_in;

     int *arc_source;

     int *arc_target;

     int *arc_next_in;

     int *arc_next_out;

   };

   typedef DigraphExtender<StaticDigraphBase> ExtendedStaticDigraphBase;

   /// \ingroup graphs

   ///

   /// \brief A static directed graph class.

   ///

   /// \ref StaticDigraph is a highly efficient digraph implementation,

   /// but it is fully static.

   /// It stores only two \c int values for each node and only four \c int

   /// values for each arc. Moreover it provides faster item iteration than

   /// \ref ListDigraph and \ref SmartDigraph, especially using \c OutArcIt

   /// iterators, since its arcs are stored in an appropriate order.

   /// However it only provides build() and clear() functions and does not

   /// support any other modification of the digraph.

   ///

   /// Since this digraph structure is completely static, its nodes and arcs

   /// can be indexed with integers from the ranges <tt>[0..nodeNum()-1]</tt>

   /// and <tt>[0..arcNum()-1]</tt>, respectively.

   /// The index of an item is the same as its ID, it can be obtained

   /// using the corresponding \ref index() or \ref concepts::Digraph::id()

   /// "id()" function. A node or arc with a certain index can be obtained

   /// using node() or arc().

   ///

   /// This type fully conforms to the \ref concepts::Digraph "Digraph concept".

   /// Most of its member functions and nested classes are documented

   /// only in the concept class.

   ///

   /// This class provides constant time counting for nodes and arcs.

   ///

   /// \sa concepts::Digraph

   class StaticDigraph : public ExtendedStaticDigraphBase {

   public:

     typedef ExtendedStaticDigraphBase Parent;

   public:

     /// \brief Constructor

     ///

     /// Default constructor.

     StaticDigraph() : Parent() {}

     /// \brief The node with the given index.

     ///

     /// This function returns the node with the given index.

     /// \sa index()

     static Node node(int ix) { return Parent::nodeFromId(ix); }

     /// \brief The arc with the given index.

     ///

     /// This function returns the arc with the given index.

     /// \sa index()

     static Arc arc(int ix) { return Parent::arcFromId(ix); }

     /// \brief The index of the given node.

     ///

     /// This function returns the index of the the given node.

     /// \sa node()

     static int index(Node node) { return Parent::id(node); }

     /// \brief The index of the given arc.

     ///

     /// This function returns the index of the the given arc.

     /// \sa arc()

     static int index(Arc arc) { return Parent::id(arc); }

     /// \brief Number of nodes.

     ///

     /// This function returns the number of nodes.

     int nodeNum() const { return node_num; }

     /// \brief Number of arcs.

     ///

     /// This function returns the number of arcs.

     int arcNum() const { return arc_num; }

     /// \brief Build the digraph copying another digraph.

     ///

     /// This function builds the digraph copying another digraph of any

     /// kind. It can be called more than once, but in such case, the whole

     /// structure and all maps will be cleared and rebuilt.

     ///

     /// This method also makes possible to copy a digraph to a StaticDigraph

     /// structure using \ref DigraphCopy.

     ///

     /// \param digraph An existing digraph to be copied.

     /// \param nodeRef The node references will be copied into this map.

     /// Its key type must be \c Digraph::Node and its value type must be

     /// \c StaticDigraph::Node.

     /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap"

     /// concept.

     /// \param arcRef The arc references will be copied into this map.

     /// Its key type must be \c Digraph::Arc and its value type must be

     /// \c StaticDigraph::Arc.

     /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.

     ///

     /// \note If you do not need the arc references, then you could use

     /// \ref NullMap for the last parameter. However the node references

     /// are required by the function itself, thus they must be readable

     /// from the map.

     template <typename Digraph, typename NodeRefMap, typename ArcRefMap>

     void build(const Digraph& digraph, NodeRefMap& nodeRef, ArcRefMap& arcRef) {

       if (built) Parent::clear();

       Parent::build(digraph, nodeRef, arcRef);

     }

     /// \brief Build the digraph from an arc list.

     ///

     /// This function builds the digraph from the given arc list.

     /// It can be called more than once, but in such case, the whole

     /// structure and all maps will be cleared and rebuilt.

     ///

     /// The list of the arcs must be given in the range <tt>[begin, end)</tt>

     /// specified by STL compatible itartors whose \c value_type must be

     /// <tt>std::pair<int,int></tt>.

     /// Each arc must be specified by a pair of integer indices

     /// from the range <tt>[0..n-1]</tt>. <i>The pairs must be in a

     /// non-decreasing order with respect to their first values.</i>

     /// If the k-th pair in the list is <tt>(i,j)</tt>, then

     /// <tt>arc(k-1)</tt> will connect <tt>node(i)</tt> to <tt>node(j)</tt>.

     ///

     /// \param n The number of nodes.

     /// \param begin An iterator pointing to the beginning of the arc list.

     /// \param end An iterator pointing to the end of the arc list.

     ///

     /// For example, a simple digraph can be constructed like this.

     /// \code

     ///   std::vector<std::pair<int,int> > arcs;

     ///   arcs.push_back(std::make_pair(0,1));

     ///   arcs.push_back(std::make_pair(0,2));

     ///   arcs.push_back(std::make_pair(1,3));

     ///   arcs.push_back(std::make_pair(1,2));

     ///   arcs.push_back(std::make_pair(3,0));

     ///   StaticDigraph gr;

     ///   gr.build(4, arcs.begin(), arcs.end());

     /// \endcode

     template <typename ArcListIterator>

     void build(int n, ArcListIterator begin, ArcListIterator end) {

       if (built) Parent::clear();

       StaticDigraphBase::build(n, begin, end);

       notifier(Node()).build();

       notifier(Arc()).build();

     }

     /// \brief Clear the digraph.

     ///

     /// This function erases all nodes and arcs from the digraph.

     void clear() {

       Parent::clear();

     }

   protected:

     using Parent::fastFirstOut;

     using Parent::fastNextOut;

     using Parent::fastLastOut;

   public:

     class OutArcIt : public Arc {

     public:

       OutArcIt() { }

       OutArcIt(Invalid i) : Arc(i) { }

       OutArcIt(const StaticDigraph& digraph, const Node& node) {

         digraph.fastFirstOut(*this, node);

         digraph.fastLastOut(last, node);

         if (last == *this) *this = INVALID;

       }

       OutArcIt(const StaticDigraph& digraph, const Arc& arc) : Arc(arc) {

         if (arc != INVALID) {

           digraph.fastLastOut(last, digraph.source(arc));

         }

       }

       OutArcIt& operator++() {

         StaticDigraph::fastNextOut(*this);

         if (last == *this) *this = INVALID;

         return *this;

       }

     private:

       Arc last;

     };

     Node baseNode(const OutArcIt &arc) const {

       return Parent::source(static_cast<const Arc&>(arc));

     }

     Node runningNode(const OutArcIt &arc) const {

       return Parent::target(static_cast<const Arc&>(arc));

     }

     Node baseNode(const InArcIt &arc) const {

       return Parent::target(static_cast<const Arc&>(arc));

     }

     Node runningNode(const InArcIt &arc) const {

       return Parent::source(static_cast<const Arc&>(arc));

     }

   };

 }

 #endif