Ticket #168: df198f12f7fa.patch

tools/bp-matching-benchmark.cc

@@ -24 +24 @@
 #include <lemon/matching.h>
 #include <lemon/preflow.h>
 #include <lemon/bp_matching.h>
+#include <lemon/cost_scaling.h>
+#include <lemon/capacity_scaling.h>
+#include <lemon/network_simplex.h>
 #include <iostream>
 
 using namespace std;
@@ -55 +58 @@
   }
 }
 
+template <typename BpGraph, typename BpCostMap,
+          typename Digraph, typename DgCostMap, typename SupplyMap>
+void create_weighted_net(const BpGraph &bpg,
+                         const BpCostMap &bpcost,
+                         Digraph &dg,
+                         DgCostMap &dgcost,
+                         SupplyMap &supply)
+{
+  dg.clear();
+  typename Digraph::Node source = dg.addNode();
+  supply.set(source, countBlueNodes(bpg) - countRedNodes(bpg));
+
+  typename BpGraph::template NodeMap<typename Digraph::Node> xref(bpg);
+
+  for (typename BpGraph::RedNodeIt r(bpg); r!=INVALID; ++r) {
+    xref.set(r, dg.addNode());
+    dgcost.set(dg.addArc(xref[r], source), 0);
+    supply.set(xref[r], 1);
+  }
+  for (typename BpGraph::BlueNodeIt b(bpg); b!=INVALID; ++b) {
+    xref.set(b, dg.addNode());
+    dgcost.set(dg.addArc(source, xref[b]), 0);
+    supply.set(xref[b], -1);
+  }
+
+  for (typename BpGraph::EdgeIt e(bpg); e!=INVALID; ++e) {
+    typename Digraph::Arc a =
+      dg.addArc(xref[bpg.redNode(e)], xref[bpg.blueNode(e)]);
+    dgcost.set(a, -bpcost[e]);
+  }
+}
+
 typedef SmartDigraph Digraph;
 typedef SmartBpGraph BpGraph;
 
@@ -76 +111 @@
 /// and the \ref lemon::Preflow "Preflow" algorithms for finding
 /// a maximum cardinality bipartite matching, or the
 /// \ref lemon::MaxWeightedBpMatching "max. weighted matching
-/// for sparse bipartite graphs" and the \ref lemon::MaxWeightedMatching
-/// "max. weighted matching for general graph" to find the maximum
-/// weighted matching.
+/// for sparse bipartite graphs", the \ref lemon::MaxWeightedMatching
+/// "max. weighted matching for general graph", \ref
+/// lemon::CostScaling "cost scaling", \ref lemon::CapacityScaling
+/// "capacity scaling" and \ref lemon::NetworkSimplex "network
+/// simplex" algorithms to find the maximum weighted matching.
 int main() {
   DimacsDescriptor desc = dimacsType(cin);
+  int red_n, blue_n, edge_n = desc.edgeNum;
   if (desc.type == DimacsDescriptor::UBM) {
     // unweighted bipartite matching
     Timer hk_t(false), mm_t(false), pf_t(false);
+    int hk_r, mm_r, pf_r;
 
-    BpGraph bpg;
-    readDimacsUbm(cin, bpg, desc);
+    BpGraph *bpg = new BpGraph();
+    readDimacsUbm(cin, *bpg, desc);
+    red_n = countRedNodes(*bpg);
+    blue_n = countBlueNodes(*bpg);
 
-    Digraph network;
+    {
+      hk_t.start();
+      HopcroftKarp<BpGraph> hk(*bpg);
+      hk.run();
+      hk_r = hk.matchingSize();
+      hk_t.stop();
+    }
+    {
+      mm_t.start();
+      MaxMatching<BpGraph> mm(*bpg);
+      mm.run();
+      mm_r = mm.matchingSize();
+      mm_t.stop();
+    }
+
+    Digraph *network = new Digraph();
     Digraph::Node source, target;
-    create_network(bpg, network, source, target);
-
-    hk_t.start();
-    HopcroftKarp<BpGraph> hk(bpg);
-    hk.run();
-    hk_t.stop();
-
-    mm_t.start();
-    MaxMatching<BpGraph> mm(bpg);
-    mm.run();
-    mm_t.stop();
-
-    pf_t.start();
-    Preflow<Digraph, ConstMap<Digraph::Arc, int> >
-      pf(network, constMap<Digraph::Arc, int>(1), source, target);
-    pf.run();
-    pf_t.stop();
+    create_network(*bpg, *network, source, target);
+    delete bpg;
+    {
+      pf_t.start();
+      Preflow<Digraph, ConstMap<Digraph::Arc, long> >
+        pf(*network, constMap<Digraph::Arc, long>(1), source, target);
+      pf.run();
+      pf_r = pf.flowValue();
+      pf_t.stop();
+    }
+    delete network;
 
     cout << "Benchmarking in unweighted case, using a bipartite graph\n"
-         << "with " << countRedNodes(bpg) << " red, "
-         << countBlueNodes(bpg) << " blue nodes, and "
-         << desc.edgeNum << " edges.\n"
+         << "with " << red_n << " red, " << blue_n << " blue nodes, and "
+         << edge_n << " edges.\n"
          << "--------------------------------------------------------\n"
          << "Algorithm used       Matching size       Time\n"
-         << "Hopcroft-Karp            " << hk.matchingSize()
+         << "Hopcroft-Karp            " << hk_r
          << "         " << hk_t.realTime() << "\n"
-         << "General matching         " << mm.matchingSize()
+         << "General matching         " << mm_r
          << "         " << mm_t.realTime() << "\n"
-         << "Preflow                  " << pf.flowValue()
+         << "Preflow                  " << pf_r
          << "         " << pf_t.realTime() << endl;
 
   } else if (desc.type == DimacsDescriptor::WBM) {
     // weighted bipartite matching
-    Timer bm_t(false), gm_t(false);
+    Timer bm_t(false),
+      gm_t(false),
+      cas_t(false),
+      cos_t(false),
+      ns_t(false);
+    int bm_r, gm_r, cas_r, cos_r, ns_r;
 
-    BpGraph bpg;
-    BpGraph::EdgeMap<int> weight(bpg);
-    readDimacsWbm(cin, bpg, weight, desc);
+    BpGraph *bpg = new BpGraph();
+    BpGraph::EdgeMap<long> *weight = new BpGraph::EdgeMap<long>(*bpg);
+    readDimacsWbm(cin, *bpg, *weight, desc);
+    red_n = countRedNodes(*bpg);
+    blue_n = countBlueNodes(*bpg);
 
-    bm_t.start();
-    MaxWeightedBpMatching<BpGraph> bm(bpg, weight);
-    bm.run();
-    bm_t.stop();
+    {
+      bm_t.start();
+      MaxWeightedBpMatching<BpGraph, BpGraph::EdgeMap<long> > bm(*bpg, *weight);
+      bm.run();
+      bm_r = bm.matchingWeight();
+      bm_t.stop();
+    }
+    {
+      gm_t.start();
+      MaxWeightedMatching<BpGraph, BpGraph::EdgeMap<long> > gm(*bpg, *weight);
+      gm.run();
+      gm_r = gm.matchingWeight();
+      gm_t.stop();
+    }
 
-    gm_t.start();
-    MaxWeightedMatching<BpGraph> gm(bpg, weight);
-    gm.run();
-    gm_t.stop();
+    Digraph *g = new Digraph();
+    Digraph::ArcMap<long> *cost = new Digraph::ArcMap<long>(*g);
+    Digraph::NodeMap<long> *supply = new Digraph::NodeMap<long>(*g);
+    create_weighted_net(*bpg, *weight, *g, *cost, *supply);
+    delete bpg;
+    delete weight;
+    {
+      cas_t.start();
+      CapacityScaling<Digraph> cas(*g);
+      cas.costMap(*cost)
+        .supplyMap(*supply)
+        .upperMap(constMap<Digraph::Arc, long>(1));
+      cas.run();
+      cas_r = cas.totalCost();
+      cas_t.stop();
+    }
+    {
+      cos_t.start();
+      CostScaling<Digraph> cos(*g);
+      cos.costMap(*cost)
+        .supplyMap(*supply)
+        .upperMap(constMap<Digraph::Arc, long>(1));
+      cos.run();
+      cos_r = cos.totalCost();
+      cos_t.stop();
+    }
+    {
+      ns_t.start();
+      NetworkSimplex<Digraph> ns(*g);
+      ns.costMap(*cost)
+        .supplyMap(*supply)
+        .upperMap(constMap<Digraph::Arc, long>(1));
+      ns.run();
+      ns_r = ns.totalCost();
+      ns_t.stop();
+    }
+    delete g;
+    delete cost;
+    delete supply;
 
     cout << "Benchmarking on weighted bipartite matching problem on a "
-         << "graph\nwith " << countRedNodes(bpg) << " red, "
-         << countBlueNodes(bpg) << " blue nodes and "
-         << desc.edgeNum << " edges\n"
+         << "graph\nwith " << red_n << " red, " << blue_n
+         << " blue nodes and " << edge_n << " edges\n"
          << "--------------------------------------------------------\n"
          << "Algorithm used       Maximum weight       Time\n"
-         << "Bipartite matching       " << bm.matchingWeight()
+         << "Bipartite matching       " << bm_r
          << "         " << bm_t.realTime() << "\n"
-         << "General matching         " << gm.matchingWeight()
-         << "         " << gm_t.realTime() << endl;
+         << "General matching         " << gm_r
+         << "         " << gm_t.realTime() << "\n"
+         << "Capacity scaling         " << -cas_r
+         << "         " << cas_t.realTime() << "\n"
+         << "Cost scaling             " << -cos_r
+         << "         " << cos_t.realTime() << "\n"
+         << "Network simplex          " << -ns_r
+         << "         " << ns_t.realTime() << endl;
 
   } else {
     cerr << "Wrong problem type." << endl;

tools/unweighted-bp-gen.cc

@@ -61 +61 @@
   rnd.seed(seed);
 
 
-  long max_edge = red*blue;
+  long max_edge = static_cast<long>(red)*blue;
   long edge_left = density;
 
   if (max_edge < density) {

tools/weighted-bp-gen.cc

@@ -71 +71 @@
   rnd.seed(seed);
 
 
-  long max_edge = red*blue;
+  long max_edge = static_cast<long>(red)*blue;
   long edge_left = density;
 
   if (max_edge < density) {