source: lemon-0.x/src/work/marci/max_bipartite_matching_demo.cc @ 196:8a9b9360463e

// -*- c++ -*-
#include <iostream>
#include <fstream>
#include <vector>
#include <cstdlib>

//#include <LEDA/graph.h>
//#include <leda_graph_wrapper.h>
#include <list_graph.h>
#include <dimacs.h>
#include <time_measure.h>
#include <edmonds_karp.h>

/**
 * Inicializalja a veletlenszamgeneratort.
 * Figyelem, ez nem jo igazi random szamokhoz,
 * erre ne bizzad a titkaidat!
 */
void random_init()
{
        unsigned int seed = getpid();
        seed |= seed << 15;
        seed ^= time(0);

        srand(seed);
}

/**
 * Egy veletlen int-et ad vissza 0 es m-1 kozott.
 */
int random(int m)
{
        return int( double(m) * rand() / (RAND_MAX + 1.0) );
}

using namespace hugo;

using std::cout; 
using std::endl;

int main() {
//   leda::graph g;
//   typedef LedaGraphWrapper<leda::graph> Graph;
//   Graph G(g);
  typedef ListGraph Graph;
  Graph G;

  typedef Graph::Node Node;
  typedef Graph::NodeIt NodeIt;  
  typedef Graph::Edge Edge;
  typedef Graph::EdgeIt EdgeIt;
  typedef Graph::OutEdgeIt OutEdgeIt;
  typedef Graph::InEdgeIt InEdgeIt;

  //Node s, t;
  //Graph::EdgeMap<int> cap(G);
  //readDimacsMaxFlow(std::cin, G, s, t, cap);
  std::vector<Node> s_nodes;
  std::vector<Node> t_nodes;

  for(int i=0; i<4; ++i) {
    s_nodes.push_back(G.addNode());
  }
  for(int i=0; i<4; ++i) {
    t_nodes.push_back(G.addNode());
  }
  random_init();
  for(int i=0; i<6; ++i) {
    G.addEdge(s_nodes[random(4)], t_nodes[random(4)]);
  }
  
//   G.addEdge(s_nodes[2], t_nodes[4-4]);
//   G.addEdge(s_nodes[2], t_nodes[7-4]);
//   G.addEdge(s_nodes[2], t_nodes[4-4]);
//   G.addEdge(s_nodes[3], t_nodes[6-4]);
//   G.addEdge(s_nodes[3], t_nodes[5-4]);
//   G.addEdge(s_nodes[3], t_nodes[5-4]);


  Graph::NodeMap<bool> s_map(G); //false
  Graph::NodeMap<bool> t_map(G); //false
  
  for(int i=0; i<4; ++i) {
    s_map.set(s_nodes[i], true);
    t_map.set(t_nodes[i], true);
  }

  cout << "bfs and dfs iterator demo on the directed graph" << endl;
  for(NodeIt n=G.first<NodeIt>(); G.valid(n); G.next(n)) { 
    cout << G.id(n) << ": ";
    cout << "out edges: ";
    for(OutEdgeIt e=G.first<OutEdgeIt>(n); G.valid(e); G.next(e)) 
      cout << G.id(G.tail(e)) << "->" << G.id(G.head(e)) << " ";
    cout << "in edges: ";
    for(InEdgeIt e=G.first<InEdgeIt>(n); G.valid(e); G.next(e)) 
      cout << G.id(G.tail(e)) << "->" << G.id(G.head(e)) << " ";
    cout << endl;
  }


  {
    std::cout << "on-the-fly max bipartite matching demo on wrapped leda graph..." << std::endl;
    Graph::EdgeMap<int> flow(G); //0 flow
    Graph::EdgeMap<int> cap(G, 1);

    Timer ts;
    ts.reset();

    MaxMatching<Graph, int, Graph::EdgeMap<int>, Graph::EdgeMap<int> > max_flow_test(G, s_map, t_map, flow, cap);
    //max_flow_test.augmentWithBlockingFlow<Graph>();
    int i=0;
    while (max_flow_test.augmentOnShortestPath()) { 
//     for(EdgeIt e=G.template first<EdgeIt>(); e.valid(); ++e) { 
//       std::cout<<"("<<G.tail(e)<< "-"<<flow.get(e)<<"->"<<G.head(e)<<") ";
//     }
//     std::cout<<std::endl;
      ++i; 
    }

    std::cout << "maximum matching: "<< std::endl;
    for(EdgeIt e=G.first<EdgeIt>(); G.valid(e); G.next(e))  
      if (flow.get(e))
        std::cout << G.id(G.tail(e)) << "-" << flow.get(e) << "->" << G.id(G.head(e)) << " ";
    std::cout<<std::endl;
    std::cout << "edges which are not in this maximum matching: "<< std::endl;
    for(EdgeIt e=G.first<EdgeIt>(); G.valid(e); G.next(e))  
      if (!flow.get(e))
        std::cout << G.id(G.tail(e)) << "-" << flow.get(e) << "->" << G.id(G.head(e)) << " ";
    std::cout<<std::endl;
    
    std::cout << "elapsed time: " << ts << std::endl;
    std::cout << "number of augmentation phases: " << i << std::endl; 
    std::cout << "flow value: "<< max_flow_test.flowValue() << std::endl;
  }
  

  return 0;
}