source: lemon-0.x/lemon/euler.h @ 2553:bfced05fa852

/* -*- C++ -*-
 *
 * This file is a part of LEMON, a generic C++ optimization library
 *
 * Copyright (C) 2003-2008
 * 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.
 *
 */

#include<lemon/bits/invalid.h>
#include<lemon/topology.h>
#include <list>

/// \ingroup graph_prop
/// \file
/// \brief Euler tour
///
///This file provides an Euler tour iterator and ways to check
///if a graph is euler.


namespace lemon {

  ///Euler iterator for directed graphs.

  /// \ingroup graph_prop
  ///This iterator converts to the \c Edge type of the graph and using
  ///operator ++ it provides an Euler tour of a \e directed
  ///graph (if there exists).
  ///
  ///For example
  ///if the given graph if Euler (i.e it has only one nontrivial component
  ///and the in-degree is equal to the out-degree for all nodes),
  ///the following code will put the edges of \c g
  ///to the vector \c et according to an
  ///Euler tour of \c g.
  ///\code
  ///  std::vector<ListGraph::Edge> et;
  ///  for(EulerIt<ListGraph> e(g),e!=INVALID;++e)
  ///    et.push_back(e);
  ///\endcode
  ///If \c g is not Euler then the resulted tour will not be full or closed.
  ///\sa UEulerIt
  ///\todo Test required
  template<class Graph>
  class EulerIt 
  {
    typedef typename Graph::Node Node;
    typedef typename Graph::NodeIt NodeIt;
    typedef typename Graph::Edge Edge;
    typedef typename Graph::EdgeIt EdgeIt;
    typedef typename Graph::OutEdgeIt OutEdgeIt;
    typedef typename Graph::InEdgeIt InEdgeIt;
    
    const Graph &g;
    typename Graph::template NodeMap<OutEdgeIt> nedge;
    std::list<Edge> euler;

  public:
    
    ///Constructor

    ///\param _g A directed graph.
    ///\param start The starting point of the tour. If it is not given
    ///       the tour will start from the first node.
    EulerIt(const Graph &_g,typename Graph::Node start=INVALID)
      : g(_g), nedge(g)
    {
      if(start==INVALID) start=NodeIt(g);
      for(NodeIt n(g);n!=INVALID;++n) nedge[n]=OutEdgeIt(g,n);
      while(nedge[start]!=INVALID) {
        euler.push_back(nedge[start]);
        Node next=g.target(nedge[start]);
        ++nedge[start];
        start=next;
      }
    }
    
    ///Edge Conversion
    operator Edge() { return euler.empty()?INVALID:euler.front(); }
    bool operator==(Invalid) { return euler.empty(); }
    bool operator!=(Invalid) { return !euler.empty(); }
    
    ///Next edge of the tour
    EulerIt &operator++() {
      Node s=g.target(euler.front());
      euler.pop_front();
      //This produces a warning.Strange.
      //std::list<Edge>::iterator next=euler.begin();
      typename std::list<Edge>::iterator next=euler.begin();
      while(nedge[s]!=INVALID) {
        euler.insert(next,nedge[s]);
        Node n=g.target(nedge[s]);
        ++nedge[s];
        s=n;
      }
      return *this;
    }
    ///Postfix incrementation
    
    ///\warning This incrementation
    ///returns an \c Edge, not an \ref EulerIt, as one may
    ///expect.
    Edge operator++(int) 
    {
      Edge e=*this;
      ++(*this);
      return e;
    }
  };

  ///Euler iterator for undirected graphs.

  /// \ingroup graph_prop
  ///This iterator converts to the \c Edge (or \c UEdge)
  ///type of the graph and using
  ///operator ++ it provides an Euler tour of an undirected
  ///graph (if there exists).
  ///
  ///For example
  ///if the given graph if Euler (i.e it has only one nontrivial component
  ///and the degree of each node is even),
  ///the following code will print the edge IDs according to an
  ///Euler tour of \c g.
  ///\code
  ///  for(UEulerIt<ListUGraph> e(g),e!=INVALID;++e) {
  ///    std::cout << g.id(UEdge(e)) << std::eol;
  ///  }
  ///\endcode
  ///Although the iterator provides an Euler tour of an undirected graph,
  ///in order to indicate the direction of the tour, UEulerIt
  ///returns directed edges (that convert to the undirected ones, of course).
  ///
  ///If \c g is not Euler then the resulted tour will not be full or closed.
  ///\sa EulerIt
  ///\todo Test required
  template<class Graph>
  class UEulerIt
  {
    typedef typename Graph::Node Node;
    typedef typename Graph::NodeIt NodeIt;
    typedef typename Graph::Edge Edge;
    typedef typename Graph::UEdge UEdge;
    typedef typename Graph::EdgeIt EdgeIt;
    typedef typename Graph::OutEdgeIt OutEdgeIt;
    typedef typename Graph::InEdgeIt InEdgeIt;
    
    const Graph &g;
    typename Graph::template NodeMap<OutEdgeIt> nedge;
    typename Graph::template UEdgeMap<bool> visited;
    std::list<Edge> euler;

  public:
    
    ///Constructor

    ///\param _g An undirected graph.
    ///\param start The starting point of the tour. If it is not given
    ///       the tour will start from the first node.
    UEulerIt(const Graph &_g,typename Graph::Node start=INVALID)
      : g(_g), nedge(g), visited(g,false)
    {
      if(start==INVALID) start=NodeIt(g);
      for(NodeIt n(g);n!=INVALID;++n) nedge[n]=OutEdgeIt(g,n);
      while(nedge[start]!=INVALID) {
        euler.push_back(nedge[start]);
        visited[nedge[start]]=true;
        Node next=g.target(nedge[start]);
        ++nedge[start];
        start=next;
        while(nedge[start]!=INVALID && visited[nedge[start]]) ++nedge[start];
      }
    }
    
    ///Edge Conversion
    operator Edge() const { return euler.empty()?INVALID:euler.front(); }
    ///Edge Conversion
    operator UEdge() const { return euler.empty()?INVALID:euler.front(); }
    ///\e
    bool operator==(Invalid) const { return euler.empty(); }
    ///\e
    bool operator!=(Invalid) const { return !euler.empty(); }
    
    ///Next edge of the tour
    UEulerIt &operator++() {
      Node s=g.target(euler.front());
      euler.pop_front();
      typename std::list<Edge>::iterator next=euler.begin();

      while(nedge[s]!=INVALID) {
        while(nedge[s]!=INVALID && visited[nedge[s]]) ++nedge[s];
        if(nedge[s]==INVALID) break;
        else {
          euler.insert(next,nedge[s]);
          visited[nedge[s]]=true;
          Node n=g.target(nedge[s]);
          ++nedge[s];
          s=n;
        }
      }
      return *this;
    }
    
    ///Postfix incrementation
    
    ///\warning This incrementation
    ///returns an \c Edge, not an \ref UEulerIt, as one may
    ///expect.
    Edge operator++(int) 
    {
      Edge e=*this;
      ++(*this);
      return e;
    }
  };


  ///Checks if the graph is Euler

  /// \ingroup graph_prop
  ///Checks if the graph is Euler. It works for both directed and
  ///undirected graphs.
  ///\note By definition, a directed graph is called \e Euler if
  ///and only if connected and the number of it is incoming and outgoing edges
  ///are the same for each node.
  ///Similarly, an undirected graph is called \e Euler if
  ///and only if it is connected and the number of incident edges is even
  ///for each node. <em>Therefore, there are graphs which are not Euler, but
  ///still have an Euler tour</em>.
  ///\todo Test required
  template<class Graph>
#ifdef DOXYGEN
  bool
#else
  typename enable_if<UndirectedTagIndicator<Graph>,bool>::type
  euler(const Graph &g) 
  {
    for(typename Graph::NodeIt n(g);n!=INVALID;++n)
      if(countIncEdges(g,n)%2) return false;
    return connected(g);
  }
  template<class Graph>
  typename disable_if<UndirectedTagIndicator<Graph>,bool>::type
#endif
  euler(const Graph &g) 
  {
    for(typename Graph::NodeIt n(g);n!=INVALID;++n)
      if(countInEdges(g,n)!=countOutEdges(g,n)) return false;
    return connected(g);
  }
  
}