Changeset 99:f26897fb91fd in lemon-0.x for src/work/bfs_iterator.hh

Timestamp:

02/18/04 16:58:28 (20 years ago)

Author:

marci

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@128

Message:

dfs iterator: DfsIterator4 improved version

File:

• src/work/bfs_iterator.hh (modified) (2 diffs)

src/work/bfs_iterator.hh

@@ -284 +284 @@
     operator OutEdgeIt () { return actual_edge; }
     bool bNodeIsNewlyReached() { return b_node_newly_reached; }
-    bool aNodeIsLeaved() { return !(actual_edge.valid()); }
+    bool aNodeIsExamined() { return !(actual_edge.valid()); }
   };
 
@@ -615 +615 @@
 
 
+  template <typename Graph, typename OutEdgeIt, typename ReachedMap>
+  struct DfsIterator4 {
+    typedef typename Graph::NodeIt NodeIt;
+    const Graph& G;
+    std::stack<OutEdgeIt> dfs_stack;
+    //ReachedMap& reached;
+    bool b_node_newly_reached;
+    OutEdgeIt actual_edge;
+    NodeIt actual_node;
+    ReachedMap reached;
+    DfsIterator4(const Graph& _G 
+                 /*, std::stack<OutEdgeIt>& _bfs_queue, 
+                   ReachedMap& _reached*/) : 
+      G(_G), reached(G, false) /*, bfs_queue(_bfs_queue), reached(_reached)*/ { 
+      //actual_edge=bfs_queue.top();
+      //if (actual_edge.valid()) { 
+      //        NodeIt w=G.bNode(actual_edge);
+      //if (!reached.get(w)) {
+      //  bfs_queue.push(OutEdgeIt(G, w));
+      //  reached.set(w, true);
+      //  b_node_newly_reached=true;
+      //} else {
+      //  ++(bfs_queue.top());
+      //  b_node_newly_reached=false;
+      //}
+      //} else {
+      //        bfs_queue.pop();
+      //}
+    }
+    void pushAndSetReached(NodeIt s) { 
+      reached.set(s, true);
+      dfs_stack.push(G.template first<OutEdgeIt>(s)); 
+    }
+    DfsIterator4<Graph, OutEdgeIt, ReachedMap>& 
+    operator++() { 
+      actual_edge=dfs_stack.top();
+      //actual_node=G.aNode(actual_edge);
+      if (actual_edge.valid()) { 
+        NodeIt w=G.bNode(actual_edge);
+        actual_node=w;
+        if (!reached.get(w)) {
+          dfs_stack.push(G.template first<OutEdgeIt>(w));
+          reached.set(w, true);
+          b_node_newly_reached=true;
+        } else {
+          ++(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 !(actual_edge.valid()); }
+    NodeIt aNode() const { return actual_node; }
+    NodeIt bNode() const { return G.bNode(actual_edge); }
+    const ReachedMap& getReachedMap() const { return reached; }
+    const std::stack<OutEdgeIt>& getDfsStack() const { return dfs_stack; }
+  };
+
+
+
   template <typename GraphWrapper, typename ReachedMap>
   class BfsIterator5 {