src/work/jacint/reverse_bfs.hh
changeset 143 c1ec00df3b3a
parent 78 ecc1171307be
equal deleted inserted replaced
2:0cdc752db550 -1:000000000000
     1 /*
       
     2 reverse_bfs
       
     3 by jacint
       
     4 Performs a bfs on the out Edges. It does not count predecessors, 
       
     5 only the distances, but one can easily modify it to know the pred as well.
       
     6 
       
     7 Constructor: 
       
     8 
       
     9 reverse_bfs(graph_type& G, NodeIt t)
       
    10 
       
    11 
       
    12 
       
    13 Member functions:
       
    14 
       
    15 void run(): runs a reverse bfs from t
       
    16 
       
    17   The following function should be used after run() was already run.
       
    18 
       
    19 int dist(NodeIt v) : returns the distance from v to t. It is the number of Nodes if t is not reachable from v.
       
    20 
       
    21 */
       
    22 #ifndef REVERSE_BFS_HH
       
    23 #define REVERSE_BFS_HH
       
    24 
       
    25 #include <queue>
       
    26 
       
    27 #include <marci_graph_traits.hh>
       
    28 #include <marciMap.hh>
       
    29 
       
    30 
       
    31 
       
    32 namespace  marci {
       
    33 
       
    34   template <typename graph_type>
       
    35   class reverse_bfs {
       
    36     typedef typename graph_traits<graph_type>::NodeIt NodeIt;
       
    37     //typedef typename graph_traits<graph_type>::EdgeIt EdgeIt;
       
    38     typedef typename graph_traits<graph_type>::EachNodeIt EachNodeIt;
       
    39     typedef typename graph_traits<graph_type>::InEdgeIt InEdgeIt;
       
    40 
       
    41 
       
    42     graph_type& G;
       
    43     NodeIt t;
       
    44 //    NodeMap<graph_type, EdgeIt> pred;
       
    45     NodeMap<graph_type, int> distance;
       
    46     
       
    47 
       
    48   public :
       
    49 
       
    50     /*
       
    51       The distance of the Nodes is n, except t for which it is 0.
       
    52     */
       
    53     reverse_bfs(graph_type& _G, NodeIt _t) : G(_G), t(_t), distance(G, number_of(G.first_Node())) {
       
    54       distance.put(t,0);
       
    55     }
       
    56     
       
    57     void run() {
       
    58 
       
    59       NodeMap<graph_type, bool> reached(G, false); 
       
    60       reached.put(t, true);
       
    61 
       
    62       std::queue<NodeIt> bfs_queue;
       
    63       bfs_queue.push(t);
       
    64 
       
    65       while (!bfs_queue.empty()) {
       
    66 
       
    67         NodeIt v=bfs_queue.front();	
       
    68 	bfs_queue.pop();
       
    69 
       
    70 	for(InEdgeIt e=G.template first<InEdgeIt>(v); e.valid(); ++e) {
       
    71 	  NodeIt w=G.tail(e);
       
    72 	  if (!reached.get(w)) {
       
    73 	    bfs_queue.push(w);
       
    74 	    distance.put(w, distance.get(v)+1);
       
    75 	    reached.put(w, true);
       
    76 	  }
       
    77 	}
       
    78       }
       
    79     }
       
    80 
       
    81 
       
    82 
       
    83     int dist(NodeIt v) {
       
    84       return distance.get(v);
       
    85     }
       
    86 
       
    87 
       
    88   };
       
    89 
       
    90 } // namespace hugo
       
    91 
       
    92 #endif //REVERSE_BFS_HH
       
    93 
       
    94