source: lemon-0.x/test/arborescence_test.cc @ 2321:e23a610bed51

#include <iostream>
#include <set>
#include <vector>
#include <iterator>

#include <cmath>
#include <cstdlib>

#include <lemon/smart_graph.h>
#include <lemon/min_cost_arborescence.h>

#include <lemon/graph_utils.h>
#include <lemon/time_measure.h>

#include <lemon/tolerance.h>

#include "test_tools.h"

using namespace lemon;
using namespace std;

const int n = 10;
const int e = 22;

int sourceNode = 0;

int sources[e] = {
  1, 0, 2, 4, 4, 3, 9, 8, 9, 8,
  4, 2, 0, 6, 4, 1, 7, 2, 8, 6,
  1, 0
};

int targets[e] = {
  8, 3, 1, 1, 4, 9, 8, 1, 8, 0,
  3, 2, 1, 3, 1, 1, 2, 6, 3, 9,
  1, 3
};

double costs[e] = {
  107.444, 70.3069, 46.0496, 28.3962, 91.4325,
  76.9443, 61.986, 39.3754, 74.9575, 39.3153,
  45.7094, 34.6184, 100.156, 95.726, 22.3429,
  31.587, 51.6972, 29.6773, 115.038, 32.4137,
  60.0038, 40.1237
};



int main() {
  typedef SmartGraph Graph;
  GRAPH_TYPEDEFS(Graph);

  typedef Graph::EdgeMap<double> CostMap;

  Graph graph;
  CostMap cost(graph);
  vector<Node> nodes;
  
  for (int i = 0; i < n; ++i) {
    nodes.push_back(graph.addNode());
  }

  for (int i = 0; i < e; ++i) {
    Edge edge = graph.addEdge(nodes[sources[i]], nodes[targets[i]]);
    cost[edge] = costs[i];
  }

  Node source = nodes[sourceNode];

  MinCostArborescence<Graph, CostMap> mca(graph, cost);
  mca.run(source);

  vector<pair<double, set<Node> > > dualSolution(mca.dualSize());

  for (int i = 0; i < mca.dualSize(); ++i) {
    dualSolution[i].first = mca.dualValue(i);
    for (MinCostArborescence<Graph, CostMap>::DualIt it(mca, i); 
         it != INVALID; ++it) {
      dualSolution[i].second.insert(it);
    }
  }

  Tolerance<double> tolerance;

  for (EdgeIt it(graph); it != INVALID; ++it) {
    if (mca.reached(graph.source(it))) {
      double sum = 0.0;
      for (int i = 0; i < (int)dualSolution.size(); ++i) {
        if (dualSolution[i].second.find(graph.target(it)) 
            != dualSolution[i].second.end() &&
            dualSolution[i].second.find(graph.source(it)) 
            == dualSolution[i].second.end()) {
          sum += dualSolution[i].first;
        }
      }
      if (mca.arborescence(it)) {
        check(!tolerance.less(sum, cost[it]), "INVALID DUAL");
      }
      check(!tolerance.less(cost[it], sum), "INVALID DUAL");
    }
  }


  check(!tolerance.different(mca.dualValue(), mca.arborescenceValue()),
               "INVALID DUAL");


  check(mca.reached(source), "INVALID ARBORESCENCE");
  for (EdgeIt it(graph); it != INVALID; ++it) {
    check(!mca.reached(graph.source(it)) || 
                 mca.reached(graph.target(it)), "INVALID ARBORESCENCE");
  }

  for (NodeIt it(graph); it != INVALID; ++it) {
    if (!mca.reached(it)) continue;
    int cnt = 0;
    for (InEdgeIt jt(graph, it); jt != INVALID; ++jt) {
      if (mca.arborescence(jt)) {
        ++cnt;
      }
    }
    check((it == source ? cnt == 0 : cnt == 1), "INVALID ARBORESCENCE");
  }
  
  return 0;
}