// -*- c++ -*-

#include <iostream>

#include <fstream>

#include <sage_graph.h>

//#include <smart_graph.h>

#include <lemon/dimacs.h>

#include <lemon/time_measure.h>

#include <lemon/for_each_macros.h>

#include <bfs_dfs.h>

using namespace lemon;

int main() {

  typedef SageGraph Graph; 

  typedef Graph::Node Node;

  typedef Graph::NodeIt NodeIt;

  typedef Graph::Edge Edge;

  typedef Graph::EdgeIt EdgeIt;

  typedef Graph::OutEdgeIt OutEdgeIt;

  Graph g;

  Node s, t;

  Graph::EdgeMap<int> cap(g);

  //readDimacsMaxFlow(std::cin, g, s, t, cap);

  readDimacs(std::cin, g);

  Graph::NodeMap<OutEdgeIt> pred(g);

  Timer ts;

  /*

  {

    ts.reset();

    Graph::NodeMap<bool> reached(g);

    reached.set(s, true);

    pred.set(s, INVALID);

    std::queue<Node> bfs_queue;

    bfs_queue.push(t);

    while (!bfs_queue.empty()) {

      Node v=bfs_queue.front();	

      bfs_queue.pop();

      OutEdgeIt e;

      for(g.first(e,v); g.valid(e); g.next(e)) {

	Node w=g.head(e);

	if (!reached[w]) {

	  bfs_queue.push(w);

	  reached.set(w, true);

	  pred.set(w, e);

	}

      }

    }

    std::cout << ts << std::endl;

  }

  */

  {

    ts.reset();

    Graph::NodeMap<bool> bfs_reached(g);

    Graph::NodeMap<Edge> bfs_pred(g); 

    Graph::NodeMap<int> bfs_dist(g);

    Bfs< Graph, Graph::NodeMap<bool>, 

      Graph::NodeMap<Edge>, Graph::NodeMap<int> > 

      bfs(g,bfs_reached, bfs_pred, bfs_dist );

    bfs.run(s);

    /*

    pred.set(s, INVALID);

    while (!bfs.finished()) { 

      ++bfs; 

      if (g.valid(bfs) && bfs.isBNodeNewlyReached()) 

	pred.set(bfs.bNode(), bfs);

    }

    */

    std::cout << ts << std::endl;

  }

  return 0;

}