#include <cstdlib>

 #include <iostream>

 #include <sstream>

 #include <lemon/smart_graph.h>

 #include <lemon/list_graph.h>

 #include <lemon/bpugraph_adaptor.h>

 #include <lemon/bipartite_matching.h>

 #include <lemon/graph_utils.h>

 #include <lemon/dim2.h>

 #include <lemon/graph_to_eps.h>

 #include <lemon/time_measure.h>

 using namespace std;

 using namespace lemon;

 typedef SmartBpUGraph Graph;

 typedef ListBpUGraph LGraph;

 BPUGRAPH_TYPEDEFS(Graph);

 int _urandom_init() {

   int seed = time(0);

   srand(seed);

   return seed;

 }

 int urandom(int n) {

   static int seed = _urandom_init();

   ignore_unused_variable_warning(seed);

   return (int)(rand() / (1.0 + RAND_MAX) * n);

 }

 int main() {

   for (int k = 1; k < 100; ++k) {

     int n = k * 100;

     int m = (100 - k) * 100;

     int e = 20000;

     int s = 100;

     Timer nt(false), st(false);

     Timer lnt(false), lst(false);

     for (int i = 0; i < s; ++i) {

       Graph graph;

       LGraph lgraph;

       vector<Node> aNodes;

       vector<Node> bNodes;  

       vector<LGraph::Node> laNodes;

       vector<LGraph::Node> lbNodes;  

       for (int i = 0; i < n; ++i) {

         Node node = graph.addANode();

         aNodes.push_back(node);

         LGraph::Node lnode = lgraph.addANode();

         laNodes.push_back(lnode);

       }

       for (int i = 0; i < m; ++i) {

         Node node = graph.addBNode();

         bNodes.push_back(node);

         LGraph::Node lnode = lgraph.addBNode();

         lbNodes.push_back(lnode);

       }

       for (int i = 0; i < e; ++i) {

         int a,b;

 	Node aNode = aNodes[a=urandom(n)];

         Node bNode = bNodes[b=urandom(m)];

         graph.addEdge(aNode, bNode);

 	LGraph::Node laNode = laNodes[a];

         LGraph::Node lbNode = lbNodes[b];

         lgraph.addEdge(laNode, lbNode);

       }

       {

         MaxBipartiteMatching<Graph> bpmatch(graph);

         nt.start();

         bpmatch.init();

         bpmatch.start();

         nt.stop();

       }

       {

         typedef SwapBpUGraphAdaptor<Graph> SGraph;

         SGraph sgraph(graph);

         MaxBipartiteMatching<SGraph> bpmatch(sgraph);

         st.start();

         bpmatch.init();

         bpmatch.start();

         st.stop();

       }                 

       {

         MaxBipartiteMatching<LGraph> bpmatch(lgraph);

         lnt.start();

         bpmatch.init();

         bpmatch.start();

         lnt.stop();

       }

       {

         typedef SwapBpUGraphAdaptor<LGraph> SGraph;

         SGraph sgraph(lgraph);

         MaxBipartiteMatching<SGraph> bpmatch(sgraph);

         lst.start();

         bpmatch.init();

         bpmatch.start();

         lst.stop();

       }

      }

     cout << k * 100 << ' ' << nt.realTime() << ' ' << st.realTime()

 	 << ' ' << lnt.realTime() << ' ' << lst.realTime()<< endl;

   }

   return 0;

 }