source: lemon-0.x/src/work/marci/bfs_iterator.h @ 477:02b8ddcb207a

// -*- c++ -*-
#ifndef HUGO_BFS_ITERATOR_H
#define HUGO_BFS_ITERATOR_H

#include <queue>
#include <stack>
#include <utility>

namespace hugo {

  template <typename Graph, /*typename OutEdgeIt,*/ 
            typename ReachedMap/*=typename Graph::NodeMap<bool>*/ >
  class BfsIterator {
  protected:
    typedef typename Graph::Node Node;
    typedef typename Graph::OutEdgeIt OutEdgeIt;
    const Graph* graph;
    std::queue<Node> bfs_queue;
    ReachedMap& reached;
    bool b_node_newly_reached;
    OutEdgeIt actual_edge;
    bool own_reached_map;
  public:
    BfsIterator(const Graph& _graph, ReachedMap& _reached) : 
      graph(&_graph), reached(_reached), 
      own_reached_map(false) { }
    BfsIterator(const Graph& _graph) : 
      graph(&_graph), reached(*(new ReachedMap(*graph /*, false*/))), 
      own_reached_map(true) { }
    ~BfsIterator() { if (own_reached_map) delete &reached; }
    /// This method markes s reached.
    /// If the queue is empty, then s is pushed in the bfs queue 
    /// and the first OutEdgeIt is processed.
    /// If the queue is not empty, then s is simply pushed.
    void pushAndSetReached(Node s) { 
      reached.set(s, true);
      if (bfs_queue.empty()) {
        bfs_queue.push(s);
        graph->first(actual_edge, s);
        if (graph->valid(actual_edge)) { 
          Node w=graph->bNode(actual_edge);
          if (!reached[w]) {
            bfs_queue.push(w);
            reached.set(w, true);
            b_node_newly_reached=true;
          } else {
            b_node_newly_reached=false;
          }
        } 
      } else {
        bfs_queue.push(s);
      }
    }
    /// As \c BfsIterator<Graph, ReachedMap> works as an edge-iterator, 
    /// its \c operator++() iterates on the edges in a bfs order.
    BfsIterator<Graph, /*OutEdgeIt,*/ ReachedMap>& 
    operator++() { 
      if (graph->valid(actual_edge)) { 
        graph->next(actual_edge);
        if (graph->valid(actual_edge)) {
          Node w=graph->bNode(actual_edge);
          if (!reached[w]) {
            bfs_queue.push(w);
            reached.set(w, true);
            b_node_newly_reached=true;
          } else {
            b_node_newly_reached=false;
          }
        }
      } else {
        bfs_queue.pop(); 
        if (!bfs_queue.empty()) {
          graph->first(actual_edge, bfs_queue.front());
          if (graph->valid(actual_edge)) {
            Node w=graph->bNode(actual_edge);
            if (!reached[w]) {
              bfs_queue.push(w);
              reached.set(w, true);
              b_node_newly_reached=true;
            } else {
              b_node_newly_reached=false;
            }
          }
        }
      }
      return *this;
    }
    bool finished() const { return bfs_queue.empty(); }
    /// The conversion operator makes for converting the bfs-iterator 
    /// to an \c out-edge-iterator.
    operator OutEdgeIt() const { return actual_edge; }
    bool isBNodeNewlyReached() const { return b_node_newly_reached; }
    bool isANodeExamined() const { return !(graph->valid(actual_edge)); }
    Node aNode() const { return bfs_queue.front(); }
    Node bNode() const { return graph->bNode(actual_edge); }
    const ReachedMap& getReachedMap() const { return reached; }
    const std::queue<Node>& getBfsQueue() const { return bfs_queue; }
  };  

  /// Bfs searches from s for the nodes wich are not marked in 
  /// \c reached_map
  /// Reached is a read-write bool-map, Pred is a write-nodemap 
  /// and dist is an rw-nodemap, have to be.
  template <typename Graph, 
            typename ReachedMap=typename Graph::template NodeMap<bool>, 
            typename PredMap
            =typename Graph::template NodeMap<typename Graph::Edge>, 
            typename DistMap=typename Graph::template NodeMap<int> > 
  class Bfs : public BfsIterator<Graph, ReachedMap> {
    typedef BfsIterator<Graph, ReachedMap> Parent;
  protected:
    typedef typename Parent::Node Node;
    PredMap& pred;
    DistMap& dist;
  public:
    Bfs<Graph, ReachedMap, PredMap, DistMap>(const Graph& _graph, ReachedMap& _reached, PredMap& _pred, DistMap& _dist) : BfsIterator<Graph, ReachedMap>(_graph, _reached), pred(&_pred), dist(&_dist) { }
    /// s is marked to be reached and pushed in the bfs queue.
    /// If the queue is empty, then the first out-edge is processed.
    /// If s was not marked previously, then 
    /// in addition its pred is set to be INVALID, and dist to 0. 
    /// if s was marked previuosly, then it is simply pushed.
    void push(Node s) { 
      if (this->reached[s]) {
        Parent::pushAndSetReached(s);
      } else {
        Parent::pushAndSetReached(s);
        pred.set(s, INVALID);
        dist.set(s, 0);
      }
    }
    /// A bfs is processed from s.
    void run(Node s) {
      push(s);
      while (!this->finished()) this->operator++();
    }
    Bfs<Graph, ReachedMap, PredMap, DistMap> operator++() {
      Parent::operator++();
      if (this->graph->valid(this->actual_edge) && this->b_node_newly_reached) 
      {
        pred.set(this->bNode(), this->actual_edge);
        dist.set(this->bNode(), dist[this->aNode()]);
      }
      return *this;
    }
    const PredMap& getPredMap() const { return pred; }
    const DistMap& getDistMap() const { return dist; }
  };

  template <typename Graph, /*typename OutEdgeIt,*/ 
            typename ReachedMap/*=typename Graph::NodeMap<bool>*/ >
  class DfsIterator {
  protected:
    typedef typename Graph::Node Node;
    typedef typename Graph::OutEdgeIt OutEdgeIt;
    const Graph* graph;
    std::stack<OutEdgeIt> dfs_stack;
    bool b_node_newly_reached;
    OutEdgeIt actual_edge;
    Node actual_node;
    ReachedMap& reached;
    bool own_reached_map;
  public:
    DfsIterator(const Graph& _graph, ReachedMap& _reached) : 
      graph(&_graph), reached(_reached), 
      own_reached_map(false) { }
    DfsIterator(const Graph& _graph) : 
      graph(&_graph), reached(*(new ReachedMap(*graph /*, false*/))), 
      own_reached_map(true) { }
    ~DfsIterator() { if (own_reached_map) delete &reached; }
    void pushAndSetReached(Node s) { 
      actual_node=s;
      reached.set(s, true);
      OutEdgeIt e;
      graph->first(e, s);
      dfs_stack.push(e); 
    }
    DfsIterator<Graph, /*OutEdgeIt,*/ ReachedMap>& 
    operator++() { 
      actual_edge=dfs_stack.top();
      //actual_node=G.aNode(actual_edge);
      if (graph->valid(actual_edge)/*.valid()*/) { 
        Node w=graph->bNode(actual_edge);
        actual_node=w;
        if (!reached[w]) {
          OutEdgeIt e;
          graph->first(e, w);
          dfs_stack.push(e);
          reached.set(w, true);
          b_node_newly_reached=true;
        } else {
          actual_node=graph->aNode(actual_edge);
          graph->next(dfs_stack.top());
          b_node_newly_reached=false;
        }
      } else {
        //actual_node=G.aNode(dfs_stack.top());
        dfs_stack.pop();
      }
      return *this;
    }
    bool finished() const { return dfs_stack.empty(); }
    operator OutEdgeIt() const { return actual_edge; }
    bool isBNodeNewlyReached() const { return b_node_newly_reached; }
    bool isANodeExamined() const { return !(graph->valid(actual_edge)); }
    Node aNode() const { return actual_node; /*FIXME*/}
    Node bNode() const { return graph->bNode(actual_edge); }
    const ReachedMap& getReachedMap() const { return reached; }
    const std::stack<OutEdgeIt>& getDfsStack() const { return dfs_stack; }
  };

  /// Dfs searches from s for the nodes wich are not marked in 
  /// \c reached_map
  /// Reached is a read-write bool-map, Pred is a write-nodemap, have to be.
  template <typename Graph, 
            typename ReachedMap=typename Graph::template NodeMap<bool>, 
            typename PredMap
            =typename Graph::template NodeMap<typename Graph::Edge> > 
  class Dfs : public DfsIterator<Graph, ReachedMap> {
    typedef DfsIterator<Graph, ReachedMap> Parent;
  protected:
    typedef typename Parent::Node Node;
    PredMap& pred;
  public:
    Dfs<Graph, ReachedMap, PredMap>(const Graph& _graph, ReachedMap& _reached, PredMap& _pred) : DfsIterator<Graph, ReachedMap>(_graph, _reached), pred(&_pred) { }
    /// s is marked to be reached and pushed in the bfs queue.
    /// If the queue is empty, then the first out-edge is processed.
    /// If s was not marked previously, then 
    /// in addition its pred is set to be INVALID. 
    /// if s was marked previuosly, then it is simply pushed.
    void push(Node s) { 
      if (this->reached[s]) {
        Parent::pushAndSetReached(s);
      } else {
        Parent::pushAndSetReached(s);
        pred.set(s, INVALID);
      }
    }
    /// A bfs is processed from s.
    void run(Node s) {
      push(s);
      while (!this->finished()) this->operator++();
    }
    Dfs<Graph, ReachedMap, PredMap> operator++() {
      Parent::operator++();
      if (this->graph->valid(this->actual_edge) && this->b_node_newly_reached) 
      {
        pred.set(this->bNode(), this->actual_edge);
      }
      return *this;
    }
    const PredMap& getPredMap() const { return pred; }
  };


} // namespace hugo

#endif //HUGO_BFS_ITERATOR_H