/// \brief A structure for representing directed paths in a digraph.

   /// \brief A structure for representing directed paths in a digraph.

   ///

   ///

   /// A structure for representing directed path in a digraph.

   /// A structure for representing directed path in a digraph.

   ///

   ///

   /// In a sense, the path can be treated as a list of arcs. The

   /// In a sense, the path can be treated as a list of arcs. The

   /// lemon path type stores just this list. As a consequence, it

   /// lemon path type stores just this list. As a consequence, it

   /// cannot enumerate the nodes of the path and the source node of

   /// cannot enumerate the nodes of the path and the source node of

   /// a zero length path is undefined.

   /// a zero length path is undefined.

   /// This implementation is a back and front insertable and erasable

   /// This implementation is a back and front insertable and erasable

   /// path type. It can be indexed in O(1) time. The front and back

   /// path type. It can be indexed in O(1) time. The front and back

   /// insertion and erase is done in O(1) (amortized) time. The

   /// insertion and erase is done in O(1) (amortized) time. The

   /// implementation uses two vectors for storing the front and back

   /// implementation uses two vectors for storing the front and back

   /// insertions.

   /// insertions.

   class Path {

   class Path {

   public:

   public:

     typedef typename Digraph::Arc Arc;

     typedef typename Digraph::Arc Arc;

     /// \brief Default constructor

     /// \brief Default constructor

     ///

     ///

     /// Default constructor

     /// Default constructor

     /// \brief Reset the path to an empty one.

     /// \brief Reset the path to an empty one.

     void clear() { head.clear(); tail.clear(); }

     void clear() { head.clear(); tail.clear(); }

     /// \brief The nth arc.

     /// \brief The nth arc.

     ///

     ///

     const Arc& nth(int n) const {

     const Arc& nth(int n) const {

       return n < int(head.size()) ? *(head.rbegin() + n) :

       return n < int(head.size()) ? *(head.rbegin() + n) :

         *(tail.begin() + (n - head.size()));

         *(tail.begin() + (n - head.size()));

     }

     }

     /// \brief Initialize arc iterator to point to the nth arc

     /// \brief Initialize arc iterator to point to the nth arc

     ///

     ///

     ArcIt nthIt(int n) const {

     ArcIt nthIt(int n) const {

       return ArcIt(*this, n);

       return ArcIt(*this, n);

     }

     }

     /// \brief The first arc of the path

     /// \brief The first arc of the path

   };

   };

   /// \brief A structure for representing directed paths in a digraph.

   /// \brief A structure for representing directed paths in a digraph.

   ///

   ///

   /// A structure for representing directed path in a digraph.

   /// A structure for representing directed path in a digraph.

   ///

   ///

   /// In a sense, the path can be treated as a list of arcs. The

   /// In a sense, the path can be treated as a list of arcs. The

   /// lemon path type stores just this list. As a consequence it

   /// lemon path type stores just this list. As a consequence it

   /// cannot enumerate the nodes in the path and the zero length paths

   /// cannot enumerate the nodes in the path and the zero length paths

   /// cannot store the source.

   /// cannot store the source.

   /// This implementation is a just back insertable and erasable path

   /// This implementation is a just back insertable and erasable path

   /// type. It can be indexed in O(1) time. The back insertion and

   /// type. It can be indexed in O(1) time. The back insertion and

   /// erasure is amortized O(1) time. This implementation is faster

   /// erasure is amortized O(1) time. This implementation is faster

   /// then the \c Path type because it use just one vector for the

   /// then the \c Path type because it use just one vector for the

   /// arcs.

   /// arcs.

   class SimplePath {

   class SimplePath {

   public:

   public:

     typedef typename Digraph::Arc Arc;

     typedef typename Digraph::Arc Arc;

     /// \brief Default constructor

     /// \brief Default constructor

     ///

     ///

     /// Default constructor

     /// Default constructor

     /// \brief Reset the path to an empty one.

     /// \brief Reset the path to an empty one.

     void clear() { data.clear(); }

     void clear() { data.clear(); }

     /// \brief The nth arc.

     /// \brief The nth arc.

     ///

     ///

     const Arc& nth(int n) const {

     const Arc& nth(int n) const {

       return data[n];

       return data[n];

     }

     }

     /// \brief  Initializes arc iterator to point to the nth arc.

     /// \brief  Initializes arc iterator to point to the nth arc.

   };

   };

   /// \brief A structure for representing directed paths in a digraph.

   /// \brief A structure for representing directed paths in a digraph.

   ///

   ///

   /// A structure for representing directed path in a digraph.

   /// A structure for representing directed path in a digraph.

   ///

   ///

   /// In a sense, the path can be treated as a list of arcs. The

   /// In a sense, the path can be treated as a list of arcs. The

   /// lemon path type stores just this list. As a consequence it

   /// lemon path type stores just this list. As a consequence it

   /// cannot enumerate the nodes in the path and the zero length paths

   /// cannot enumerate the nodes in the path and the zero length paths

   /// cannot store the source.

   /// cannot store the source.

   /// This implementation is a back and front insertable and erasable

   /// This implementation is a back and front insertable and erasable

   /// path type. It can be indexed in O(k) time, where k is the rank

   /// path type. It can be indexed in O(k) time, where k is the rank

   /// of the arc in the path. The length can be computed in O(n)

   /// of the arc in the path. The length can be computed in O(n)

   /// time. The front and back insertion and erasure is O(1) time

   /// time. The front and back insertion and erasure is O(1) time

   /// and it can be splited and spliced in O(1) time.

   /// and it can be splited and spliced in O(1) time.

   class ListPath {

   class ListPath {

   public:

   public:

     typedef typename Digraph::Arc Arc;

     typedef typename Digraph::Arc Arc;

   protected:

   protected:

     // the std::list<> is incompatible

     // the std::list<> is incompatible

     };

     };

     /// \brief The nth arc.

     /// \brief The nth arc.

     ///

     ///

     /// This function looks for the nth arc in O(n) time.

     /// This function looks for the nth arc in O(n) time.

     const Arc& nth(int n) const {

     const Arc& nth(int n) const {

       Node *node = first;

       Node *node = first;

       for (int i = 0; i < n; ++i) {

       for (int i = 0; i < n; ++i) {

         node = node->next;

         node = node->next;

       }

       }

   };

   };

   /// \brief A structure for representing directed paths in a digraph.

   /// \brief A structure for representing directed paths in a digraph.

   ///

   ///

   /// A structure for representing directed path in a digraph.

   /// A structure for representing directed path in a digraph.

   ///

   ///

   /// In a sense, the path can be treated as a list of arcs. The

   /// In a sense, the path can be treated as a list of arcs. The

   /// lemon path type stores just this list. As a consequence it

   /// lemon path type stores just this list. As a consequence it

   /// cannot enumerate the nodes in the path and the source node of

   /// cannot enumerate the nodes in the path and the source node of

   /// a zero length path is undefined.

   /// a zero length path is undefined.

   /// modified.

   /// modified.

   ///

   ///

   /// Being the the most memory efficient path type in LEMON,

   /// Being the the most memory efficient path type in LEMON,

   /// it is intented to be

   /// it is intented to be

   /// used when you want to store a large number of paths.

   /// used when you want to store a large number of paths.

   class StaticPath {

   class StaticPath {

   public:

   public:

     typedef typename Digraph::Arc Arc;

     typedef typename Digraph::Arc Arc;

     /// \brief Default constructor

     /// \brief Default constructor

     ///

     ///

     /// Default constructor

     /// Default constructor

       int idx;

       int idx;

     };

     };

     /// \brief The nth arc.

     /// \brief The nth arc.

     ///

     ///

     const Arc& nth(int n) const {

     const Arc& nth(int n) const {

       return arcs[n];

       return arcs[n];

     }

     }

     /// \brief The arc iterator pointing to the nth arc.

     /// \brief The arc iterator pointing to the nth arc.