source: lemon-0.x/src/work/bfsdemo.cc @ 320:190ecba15b33

#include <iostream>
#include <graph.h>
#include <bfs.h>

using namespace NEGRO;
using namespace std;

class IGraph 
{
public:

  //  struct NodeType {bfs_node_data<TestGraph> bfs;};
  struct NodeType {bool isVis;};

  vector<NodeType> nodes;
  
  class NodeIterator 
  {
  public:
    IGraph *G;
    int n;
    NodeIterator &operator ++() { n++; return *this;}
    NodeType &operator *() const { return G->nodes[n];}
    NodeType *operator ->() const { return &(G->nodes[n]);}
    bool isValid() const {return n<=5000;}
    int Index() {return n;} //csak a kiirashoz kell

    NodeIterator() {}
    NodeIterator(IGraph &Gr) {G=&Gr;n=1;} //Bfs class prefer this.
  };
  
  void GetFirst(NodeIterator &i) {i.G=this;i.n=1;}

  class OutEdgeIterator 
  {    
  public:
    IGraph *G;
    int f,t;
    int gcd() { int a=f;int b=t;int c;while((c=a%b)) {a=b;b=c;} ; return b;}
    OutEdgeIterator &operator ++() {while(++t<=5000&&gcd()==1);return *this;}
    bool isValid() const {return t<=5000;}
    NodeIterator From() const {NodeIterator i; i.G=G;i.n=f;return i;}
    NodeIterator To() const {NodeIterator i; i.G=G;i.n=t;return i;}
    NodeIterator Anode() const {return From();}
    NodeIterator Bnode() const {return To();}

    OutEdgeIterator() {}
    OutEdgeIterator(IGraph &Gr,NodeIterator &n)  //Bfs class prefer this.
    {G=&Gr;f=n.n;t=0;operator++();}
  };

  typedef OutEdgeIterator EdgeIterator;
  void GetFirst(OutEdgeIterator &i,const NodeIterator &n)
  {i.G=this;i.f=n.n;i.t=0;++i;}

  IGraph() : nodes(5001) {}
};

class IMaps_t
{
public:
//     class_element_map<IGraph::NodeIterator,
//                  IGraph::NodeType,
//                  bool,
//                  &IGraph::NodeType::isVis> visited;
  struct _visited_map_t {
    typedef bool value_type;
    void Put(const IGraph::NodeIterator &n,const value_type &t) { n->isVis=t; }
    value_type Get(const IGraph::NodeIterator &n) const { return n->isVis; }
    void SetG(IGraph &G) {}
  } visited;
  struct _tree_map_t {
    typedef IGraph::EdgeIterator value_type;
    void Put(const IGraph::NodeIterator &n,const value_type &t)
    { cout << t.From().Index() << "->" << t.To().Index() << '\n'; }
    void SetG(IGraph &G) {}
  } tree;
  do_nothing_map dist;   //node->int (W)
  do_nothing_map priority; //node->int (W)
};

// New style bfs traits
class BFS_T 
{
public:

  typedef IGraph Graph;
  typedef IGraph::OutEdgeIterator SearchEdgeIterator;
  
  struct visited_map_t {
    typedef bool value_type;
    void Put(const IGraph::NodeIterator &n,const value_type &t) { n->isVis=t; }
    value_type Get(const IGraph::NodeIterator &n) const { return n->isVis; }
    void SetG(IGraph &G) {}
  };
  struct tree_map_t {
    typedef IGraph::EdgeIterator value_type;
    void Put(const IGraph::NodeIterator &n,const value_type &t)
    { cout << t.From().Index() << "->" << t.To().Index() << '\n'; }
    void SetG(IGraph &G) {}
  };
  typedef do_nothing_map dist_map_t;   //node->int (W)
  typedef do_nothing_map priority_map_t; //node->int (W)
};


int main()
{
  IGraph IG;

//   //Function-syte calling
//   IMaps_t IMaps;

//   IGraph::NodeIterator in;
//   IG.GetFirst(in);
//   ++in;
//   bfs_fn(IG,in,IMaps);  

  //Class-style calling:
  
  IGraph::NodeIterator in;
  IG.GetFirst(in);
  ++in;
  Bfs<BFS_T> bfs;
  bfs.SetG(IG);
  bfs.Init(in);
  bfs.Run();
}